| // SPDX-License-Identifier: GPL-2.0 |
| // |
| // Renesas R-Car SRU/SCU/SSIU/SSI support |
| // |
| // Copyright (C) 2013 Renesas Solutions Corp. |
| // Kuninori Morimoto <kuninori.morimoto.gx@renesas.com> |
| // |
| // Based on fsi.c |
| // Kuninori Morimoto <morimoto.kuninori@renesas.com> |
| |
| /* |
| * Renesas R-Car sound device structure |
| * |
| * Gen1 |
| * |
| * SRU : Sound Routing Unit |
| * - SRC : Sampling Rate Converter |
| * - CMD |
| * - CTU : Channel Count Conversion Unit |
| * - MIX : Mixer |
| * - DVC : Digital Volume and Mute Function |
| * - SSI : Serial Sound Interface |
| * |
| * Gen2 |
| * |
| * SCU : Sampling Rate Converter Unit |
| * - SRC : Sampling Rate Converter |
| * - CMD |
| * - CTU : Channel Count Conversion Unit |
| * - MIX : Mixer |
| * - DVC : Digital Volume and Mute Function |
| * SSIU : Serial Sound Interface Unit |
| * - SSI : Serial Sound Interface |
| */ |
| |
| /* |
| * driver data Image |
| * |
| * rsnd_priv |
| * | |
| * | ** this depends on Gen1/Gen2 |
| * | |
| * +- gen |
| * | |
| * | ** these depend on data path |
| * | ** gen and platform data control it |
| * | |
| * +- rdai[0] |
| * | | sru ssiu ssi |
| * | +- playback -> [mod] -> [mod] -> [mod] -> ... |
| * | | |
| * | | sru ssiu ssi |
| * | +- capture -> [mod] -> [mod] -> [mod] -> ... |
| * | |
| * +- rdai[1] |
| * | | sru ssiu ssi |
| * | +- playback -> [mod] -> [mod] -> [mod] -> ... |
| * | | |
| * | | sru ssiu ssi |
| * | +- capture -> [mod] -> [mod] -> [mod] -> ... |
| * ... |
| * | |
| * | ** these control ssi |
| * | |
| * +- ssi |
| * | | |
| * | +- ssi[0] |
| * | +- ssi[1] |
| * | +- ssi[2] |
| * | ... |
| * | |
| * | ** these control src |
| * | |
| * +- src |
| * | |
| * +- src[0] |
| * +- src[1] |
| * +- src[2] |
| * ... |
| * |
| * |
| * for_each_rsnd_dai(xx, priv, xx) |
| * rdai[0] => rdai[1] => rdai[2] => ... |
| * |
| * for_each_rsnd_mod(xx, rdai, xx) |
| * [mod] => [mod] => [mod] => ... |
| * |
| * rsnd_dai_call(xxx, fn ) |
| * [mod]->fn() -> [mod]->fn() -> [mod]->fn()... |
| * |
| */ |
| |
| #include <linux/pm_runtime.h> |
| #include "rsnd.h" |
| |
| #define RSND_RATES SNDRV_PCM_RATE_8000_192000 |
| #define RSND_FMTS (SNDRV_PCM_FMTBIT_S8 |\ |
| SNDRV_PCM_FMTBIT_S16_LE |\ |
| SNDRV_PCM_FMTBIT_S24_LE) |
| |
| static const struct of_device_id rsnd_of_match[] = { |
| { .compatible = "renesas,rcar_sound-gen1", .data = (void *)RSND_GEN1 }, |
| { .compatible = "renesas,rcar_sound-gen2", .data = (void *)RSND_GEN2 }, |
| { .compatible = "renesas,rcar_sound-gen3", .data = (void *)RSND_GEN3 }, |
| /* Special Handling */ |
| { .compatible = "renesas,rcar_sound-r8a77990", .data = (void *)(RSND_GEN3 | RSND_SOC_E) }, |
| {}, |
| }; |
| MODULE_DEVICE_TABLE(of, rsnd_of_match); |
| |
| /* |
| * rsnd_mod functions |
| */ |
| void rsnd_mod_make_sure(struct rsnd_mod *mod, enum rsnd_mod_type type) |
| { |
| if (mod->type != type) { |
| struct rsnd_priv *priv = rsnd_mod_to_priv(mod); |
| struct device *dev = rsnd_priv_to_dev(priv); |
| |
| dev_warn(dev, "%s is not your expected module\n", |
| rsnd_mod_name(mod)); |
| } |
| } |
| |
| struct dma_chan *rsnd_mod_dma_req(struct rsnd_dai_stream *io, |
| struct rsnd_mod *mod) |
| { |
| if (!mod || !mod->ops || !mod->ops->dma_req) |
| return NULL; |
| |
| return mod->ops->dma_req(io, mod); |
| } |
| |
| #define MOD_NAME_NUM 5 |
| #define MOD_NAME_SIZE 16 |
| char *rsnd_mod_name(struct rsnd_mod *mod) |
| { |
| static char names[MOD_NAME_NUM][MOD_NAME_SIZE]; |
| static int num; |
| char *name = names[num]; |
| |
| num++; |
| if (num >= MOD_NAME_NUM) |
| num = 0; |
| |
| /* |
| * Let's use same char to avoid pointlessness memory |
| * Thus, rsnd_mod_name() should be used immediately |
| * Don't keep pointer |
| */ |
| if ((mod)->ops->id_sub) { |
| snprintf(name, MOD_NAME_SIZE, "%s[%d%d]", |
| mod->ops->name, |
| rsnd_mod_id(mod), |
| rsnd_mod_id_sub(mod)); |
| } else { |
| snprintf(name, MOD_NAME_SIZE, "%s[%d]", |
| mod->ops->name, |
| rsnd_mod_id(mod)); |
| } |
| |
| return name; |
| } |
| |
| u32 *rsnd_mod_get_status(struct rsnd_mod *mod, |
| struct rsnd_dai_stream *io, |
| enum rsnd_mod_type type) |
| { |
| return &mod->status; |
| } |
| |
| int rsnd_mod_id_raw(struct rsnd_mod *mod) |
| { |
| return mod->id; |
| } |
| |
| int rsnd_mod_id(struct rsnd_mod *mod) |
| { |
| if ((mod)->ops->id) |
| return (mod)->ops->id(mod); |
| |
| return rsnd_mod_id_raw(mod); |
| } |
| |
| int rsnd_mod_id_sub(struct rsnd_mod *mod) |
| { |
| if ((mod)->ops->id_sub) |
| return (mod)->ops->id_sub(mod); |
| |
| return 0; |
| } |
| |
| int rsnd_mod_init(struct rsnd_priv *priv, |
| struct rsnd_mod *mod, |
| struct rsnd_mod_ops *ops, |
| struct clk *clk, |
| enum rsnd_mod_type type, |
| int id) |
| { |
| int ret = clk_prepare(clk); |
| |
| if (ret) |
| return ret; |
| |
| mod->id = id; |
| mod->ops = ops; |
| mod->type = type; |
| mod->clk = clk; |
| mod->priv = priv; |
| |
| return 0; |
| } |
| |
| void rsnd_mod_quit(struct rsnd_mod *mod) |
| { |
| clk_unprepare(mod->clk); |
| mod->clk = NULL; |
| } |
| |
| void rsnd_mod_interrupt(struct rsnd_mod *mod, |
| void (*callback)(struct rsnd_mod *mod, |
| struct rsnd_dai_stream *io)) |
| { |
| struct rsnd_priv *priv = rsnd_mod_to_priv(mod); |
| struct rsnd_dai *rdai; |
| int i; |
| |
| for_each_rsnd_dai(rdai, priv, i) { |
| struct rsnd_dai_stream *io = &rdai->playback; |
| |
| if (mod == io->mod[mod->type]) |
| callback(mod, io); |
| |
| io = &rdai->capture; |
| if (mod == io->mod[mod->type]) |
| callback(mod, io); |
| } |
| } |
| |
| int rsnd_io_is_working(struct rsnd_dai_stream *io) |
| { |
| /* see rsnd_dai_stream_init/quit() */ |
| if (io->substream) |
| return snd_pcm_running(io->substream); |
| |
| return 0; |
| } |
| |
| int rsnd_runtime_channel_original_with_params(struct rsnd_dai_stream *io, |
| struct snd_pcm_hw_params *params) |
| { |
| struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); |
| |
| /* |
| * params will be added when refine |
| * see |
| * __rsnd_soc_hw_rule_rate() |
| * __rsnd_soc_hw_rule_channels() |
| */ |
| if (params) |
| return params_channels(params); |
| else if (runtime) |
| return runtime->channels; |
| return 0; |
| } |
| |
| int rsnd_runtime_channel_after_ctu_with_params(struct rsnd_dai_stream *io, |
| struct snd_pcm_hw_params *params) |
| { |
| int chan = rsnd_runtime_channel_original_with_params(io, params); |
| struct rsnd_mod *ctu_mod = rsnd_io_to_mod_ctu(io); |
| |
| if (ctu_mod) { |
| u32 converted_chan = rsnd_io_converted_chan(io); |
| |
| /* |
| * !! Note !! |
| * |
| * converted_chan will be used for CTU, |
| * or TDM Split mode. |
| * User shouldn't use CTU with TDM Split mode. |
| */ |
| if (rsnd_runtime_is_tdm_split(io)) { |
| struct device *dev = rsnd_priv_to_dev(rsnd_io_to_priv(io)); |
| |
| dev_err(dev, "CTU and TDM Split should be used\n"); |
| } |
| |
| if (converted_chan) |
| return converted_chan; |
| } |
| |
| return chan; |
| } |
| |
| int rsnd_channel_normalization(int chan) |
| { |
| if (WARN_ON((chan > 8) || (chan < 0))) |
| return 0; |
| |
| /* TDM Extend Mode needs 8ch */ |
| if (chan == 6) |
| chan = 8; |
| |
| return chan; |
| } |
| |
| int rsnd_runtime_channel_for_ssi_with_params(struct rsnd_dai_stream *io, |
| struct snd_pcm_hw_params *params) |
| { |
| struct rsnd_dai *rdai = rsnd_io_to_rdai(io); |
| int chan = rsnd_io_is_play(io) ? |
| rsnd_runtime_channel_after_ctu_with_params(io, params) : |
| rsnd_runtime_channel_original_with_params(io, params); |
| |
| /* Use Multi SSI */ |
| if (rsnd_runtime_is_multi_ssi(io)) |
| chan /= rsnd_rdai_ssi_lane_get(rdai); |
| |
| return rsnd_channel_normalization(chan); |
| } |
| |
| int rsnd_runtime_is_multi_ssi(struct rsnd_dai_stream *io) |
| { |
| struct rsnd_dai *rdai = rsnd_io_to_rdai(io); |
| int lane = rsnd_rdai_ssi_lane_get(rdai); |
| int chan = rsnd_io_is_play(io) ? |
| rsnd_runtime_channel_after_ctu(io) : |
| rsnd_runtime_channel_original(io); |
| |
| return (chan > 2) && (lane > 1); |
| } |
| |
| int rsnd_runtime_is_tdm(struct rsnd_dai_stream *io) |
| { |
| return rsnd_runtime_channel_for_ssi(io) >= 6; |
| } |
| |
| int rsnd_runtime_is_tdm_split(struct rsnd_dai_stream *io) |
| { |
| return !!rsnd_flags_has(io, RSND_STREAM_TDM_SPLIT); |
| } |
| |
| /* |
| * ADINR function |
| */ |
| u32 rsnd_get_adinr_bit(struct rsnd_mod *mod, struct rsnd_dai_stream *io) |
| { |
| struct rsnd_priv *priv = rsnd_mod_to_priv(mod); |
| struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); |
| struct device *dev = rsnd_priv_to_dev(priv); |
| |
| switch (snd_pcm_format_width(runtime->format)) { |
| case 8: |
| return 16 << 16; |
| case 16: |
| return 8 << 16; |
| case 24: |
| return 0 << 16; |
| } |
| |
| dev_warn(dev, "not supported sample bits\n"); |
| |
| return 0; |
| } |
| |
| /* |
| * DALIGN function |
| */ |
| u32 rsnd_get_dalign(struct rsnd_mod *mod, struct rsnd_dai_stream *io) |
| { |
| static const u32 dalign_values[8] = { |
| 0x76543210, 0x00000032, 0x00007654, 0x00000076, |
| 0xfedcba98, 0x000000ba, 0x0000fedc, 0x000000fe, |
| }; |
| int id = 0; |
| struct rsnd_mod *ssiu = rsnd_io_to_mod_ssiu(io); |
| struct rsnd_mod *target; |
| struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); |
| u32 dalign; |
| |
| /* |
| * *Hardware* L/R and *Software* L/R are inverted for 16bit data. |
| * 31..16 15...0 |
| * HW: [L ch] [R ch] |
| * SW: [R ch] [L ch] |
| * We need to care about inversion timing to control |
| * Playback/Capture correctly. |
| * The point is [DVC] needs *Hardware* L/R, [MEM] needs *Software* L/R |
| * |
| * sL/R : software L/R |
| * hL/R : hardware L/R |
| * (*) : conversion timing |
| * |
| * Playback |
| * sL/R (*) hL/R hL/R hL/R hL/R hL/R |
| * [MEM] -> [SRC] -> [DVC] -> [CMD] -> [SSIU] -> [SSI] -> codec |
| * |
| * Capture |
| * hL/R hL/R hL/R hL/R hL/R (*) sL/R |
| * codec -> [SSI] -> [SSIU] -> [SRC] -> [DVC] -> [CMD] -> [MEM] |
| */ |
| if (rsnd_io_is_play(io)) { |
| struct rsnd_mod *src = rsnd_io_to_mod_src(io); |
| |
| target = src ? src : ssiu; |
| } else { |
| struct rsnd_mod *cmd = rsnd_io_to_mod_cmd(io); |
| |
| target = cmd ? cmd : ssiu; |
| } |
| |
| if (mod == ssiu) |
| id = rsnd_mod_id_sub(mod); |
| |
| dalign = dalign_values[id]; |
| |
| if (mod == target && snd_pcm_format_width(runtime->format) == 16) { |
| /* Target mod needs inverted DALIGN when 16bit */ |
| dalign = (dalign & 0xf0f0f0f0) >> 4 | |
| (dalign & 0x0f0f0f0f) << 4; |
| } |
| |
| return dalign; |
| } |
| |
| u32 rsnd_get_busif_shift(struct rsnd_dai_stream *io, struct rsnd_mod *mod) |
| { |
| static const enum rsnd_mod_type playback_mods[] = { |
| RSND_MOD_SRC, |
| RSND_MOD_CMD, |
| RSND_MOD_SSIU, |
| }; |
| static const enum rsnd_mod_type capture_mods[] = { |
| RSND_MOD_CMD, |
| RSND_MOD_SRC, |
| RSND_MOD_SSIU, |
| }; |
| struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); |
| struct rsnd_mod *tmod = NULL; |
| const enum rsnd_mod_type *mods = |
| rsnd_io_is_play(io) ? |
| playback_mods : capture_mods; |
| int i; |
| |
| /* |
| * This is needed for 24bit data |
| * We need to shift 8bit |
| * |
| * Linux 24bit data is located as 0x00****** |
| * HW 24bit data is located as 0x******00 |
| * |
| */ |
| if (snd_pcm_format_width(runtime->format) != 24) |
| return 0; |
| |
| for (i = 0; i < ARRAY_SIZE(playback_mods); i++) { |
| tmod = rsnd_io_to_mod(io, mods[i]); |
| if (tmod) |
| break; |
| } |
| |
| if (tmod != mod) |
| return 0; |
| |
| if (rsnd_io_is_play(io)) |
| return (0 << 20) | /* shift to Left */ |
| (8 << 16); /* 8bit */ |
| else |
| return (1 << 20) | /* shift to Right */ |
| (8 << 16); /* 8bit */ |
| } |
| |
| /* |
| * rsnd_dai functions |
| */ |
| struct rsnd_mod *rsnd_mod_next(int *iterator, |
| struct rsnd_dai_stream *io, |
| enum rsnd_mod_type *array, |
| int array_size) |
| { |
| int max = array ? array_size : RSND_MOD_MAX; |
| |
| for (; *iterator < max; (*iterator)++) { |
| enum rsnd_mod_type type = (array) ? array[*iterator] : *iterator; |
| struct rsnd_mod *mod = rsnd_io_to_mod(io, type); |
| |
| if (mod) |
| return mod; |
| } |
| |
| return NULL; |
| } |
| |
| static enum rsnd_mod_type rsnd_mod_sequence[][RSND_MOD_MAX] = { |
| { |
| /* CAPTURE */ |
| RSND_MOD_AUDMAPP, |
| RSND_MOD_AUDMA, |
| RSND_MOD_DVC, |
| RSND_MOD_MIX, |
| RSND_MOD_CTU, |
| RSND_MOD_CMD, |
| RSND_MOD_SRC, |
| RSND_MOD_SSIU, |
| RSND_MOD_SSIM3, |
| RSND_MOD_SSIM2, |
| RSND_MOD_SSIM1, |
| RSND_MOD_SSIP, |
| RSND_MOD_SSI, |
| }, { |
| /* PLAYBACK */ |
| RSND_MOD_AUDMAPP, |
| RSND_MOD_AUDMA, |
| RSND_MOD_SSIM3, |
| RSND_MOD_SSIM2, |
| RSND_MOD_SSIM1, |
| RSND_MOD_SSIP, |
| RSND_MOD_SSI, |
| RSND_MOD_SSIU, |
| RSND_MOD_DVC, |
| RSND_MOD_MIX, |
| RSND_MOD_CTU, |
| RSND_MOD_CMD, |
| RSND_MOD_SRC, |
| }, |
| }; |
| |
| static int rsnd_status_update(struct rsnd_dai_stream *io, |
| struct rsnd_mod *mod, enum rsnd_mod_type type, |
| int shift, int add, int timing) |
| { |
| u32 *status = mod->ops->get_status(mod, io, type); |
| u32 mask = 0xF << shift; |
| u8 val = (*status >> shift) & 0xF; |
| u8 next_val = (val + add) & 0xF; |
| int func_call = (val == timing); |
| |
| /* no status update */ |
| if (add == 0 || shift == 28) |
| return 1; |
| |
| if (next_val == 0xF) /* underflow case */ |
| func_call = -1; |
| else |
| *status = (*status & ~mask) + (next_val << shift); |
| |
| return func_call; |
| } |
| |
| #define rsnd_dai_call(fn, io, param...) \ |
| ({ \ |
| struct device *dev = rsnd_priv_to_dev(rsnd_io_to_priv(io)); \ |
| struct rsnd_mod *mod; \ |
| int is_play = rsnd_io_is_play(io); \ |
| int ret = 0, i; \ |
| enum rsnd_mod_type *types = rsnd_mod_sequence[is_play]; \ |
| for_each_rsnd_mod_arrays(i, mod, io, types, RSND_MOD_MAX) { \ |
| int tmp = 0; \ |
| int func_call = rsnd_status_update(io, mod, types[i], \ |
| __rsnd_mod_shift_##fn, \ |
| __rsnd_mod_add_##fn, \ |
| __rsnd_mod_call_##fn); \ |
| if (func_call > 0 && (mod)->ops->fn) \ |
| tmp = (mod)->ops->fn(mod, io, param); \ |
| if (unlikely(func_call < 0) || \ |
| unlikely(tmp && (tmp != -EPROBE_DEFER))) \ |
| dev_err(dev, "%s : %s error (%d, %d)\n", \ |
| rsnd_mod_name(mod), #fn, tmp, func_call);\ |
| ret |= tmp; \ |
| } \ |
| ret; \ |
| }) |
| |
| int rsnd_dai_connect(struct rsnd_mod *mod, |
| struct rsnd_dai_stream *io, |
| enum rsnd_mod_type type) |
| { |
| struct rsnd_priv *priv; |
| struct device *dev; |
| |
| if (!mod) |
| return -EIO; |
| |
| if (io->mod[type] == mod) |
| return 0; |
| |
| if (io->mod[type]) |
| return -EINVAL; |
| |
| priv = rsnd_mod_to_priv(mod); |
| dev = rsnd_priv_to_dev(priv); |
| |
| io->mod[type] = mod; |
| |
| dev_dbg(dev, "%s is connected to io (%s)\n", |
| rsnd_mod_name(mod), |
| rsnd_io_is_play(io) ? "Playback" : "Capture"); |
| |
| return 0; |
| } |
| |
| static void rsnd_dai_disconnect(struct rsnd_mod *mod, |
| struct rsnd_dai_stream *io, |
| enum rsnd_mod_type type) |
| { |
| io->mod[type] = NULL; |
| } |
| |
| int rsnd_rdai_channels_ctrl(struct rsnd_dai *rdai, |
| int max_channels) |
| { |
| if (max_channels > 0) |
| rdai->max_channels = max_channels; |
| |
| return rdai->max_channels; |
| } |
| |
| int rsnd_rdai_ssi_lane_ctrl(struct rsnd_dai *rdai, |
| int ssi_lane) |
| { |
| if (ssi_lane > 0) |
| rdai->ssi_lane = ssi_lane; |
| |
| return rdai->ssi_lane; |
| } |
| |
| int rsnd_rdai_width_ctrl(struct rsnd_dai *rdai, int width) |
| { |
| if (width > 0) |
| rdai->chan_width = width; |
| |
| return rdai->chan_width; |
| } |
| |
| struct rsnd_dai *rsnd_rdai_get(struct rsnd_priv *priv, int id) |
| { |
| if ((id < 0) || (id >= rsnd_rdai_nr(priv))) |
| return NULL; |
| |
| return priv->rdai + id; |
| } |
| |
| static struct snd_soc_dai_driver |
| *rsnd_daidrv_get(struct rsnd_priv *priv, int id) |
| { |
| if ((id < 0) || (id >= rsnd_rdai_nr(priv))) |
| return NULL; |
| |
| return priv->daidrv + id; |
| } |
| |
| #define rsnd_dai_to_priv(dai) snd_soc_dai_get_drvdata(dai) |
| static struct rsnd_dai *rsnd_dai_to_rdai(struct snd_soc_dai *dai) |
| { |
| struct rsnd_priv *priv = rsnd_dai_to_priv(dai); |
| |
| return rsnd_rdai_get(priv, dai->id); |
| } |
| |
| /* |
| * rsnd_soc_dai functions |
| */ |
| void rsnd_dai_period_elapsed(struct rsnd_dai_stream *io) |
| { |
| struct snd_pcm_substream *substream = io->substream; |
| |
| /* |
| * this function should be called... |
| * |
| * - if rsnd_dai_pointer_update() returns true |
| * - without spin lock |
| */ |
| |
| snd_pcm_period_elapsed(substream); |
| } |
| |
| static void rsnd_dai_stream_init(struct rsnd_dai_stream *io, |
| struct snd_pcm_substream *substream) |
| { |
| io->substream = substream; |
| } |
| |
| static void rsnd_dai_stream_quit(struct rsnd_dai_stream *io) |
| { |
| io->substream = NULL; |
| } |
| |
| static |
| struct snd_soc_dai *rsnd_substream_to_dai(struct snd_pcm_substream *substream) |
| { |
| struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); |
| |
| return asoc_rtd_to_cpu(rtd, 0); |
| } |
| |
| static |
| struct rsnd_dai_stream *rsnd_rdai_to_io(struct rsnd_dai *rdai, |
| struct snd_pcm_substream *substream) |
| { |
| if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) |
| return &rdai->playback; |
| else |
| return &rdai->capture; |
| } |
| |
| static int rsnd_soc_dai_trigger(struct snd_pcm_substream *substream, int cmd, |
| struct snd_soc_dai *dai) |
| { |
| struct rsnd_priv *priv = rsnd_dai_to_priv(dai); |
| struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai); |
| struct rsnd_dai_stream *io = rsnd_rdai_to_io(rdai, substream); |
| int ret; |
| unsigned long flags; |
| |
| spin_lock_irqsave(&priv->lock, flags); |
| |
| switch (cmd) { |
| case SNDRV_PCM_TRIGGER_START: |
| case SNDRV_PCM_TRIGGER_RESUME: |
| ret = rsnd_dai_call(init, io, priv); |
| if (ret < 0) |
| goto dai_trigger_end; |
| |
| ret = rsnd_dai_call(start, io, priv); |
| if (ret < 0) |
| goto dai_trigger_end; |
| |
| ret = rsnd_dai_call(irq, io, priv, 1); |
| if (ret < 0) |
| goto dai_trigger_end; |
| |
| break; |
| case SNDRV_PCM_TRIGGER_STOP: |
| case SNDRV_PCM_TRIGGER_SUSPEND: |
| ret = rsnd_dai_call(irq, io, priv, 0); |
| |
| ret |= rsnd_dai_call(stop, io, priv); |
| |
| ret |= rsnd_dai_call(quit, io, priv); |
| |
| break; |
| default: |
| ret = -EINVAL; |
| } |
| |
| dai_trigger_end: |
| spin_unlock_irqrestore(&priv->lock, flags); |
| |
| return ret; |
| } |
| |
| static int rsnd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) |
| { |
| struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai); |
| |
| /* set clock master for audio interface */ |
| switch (fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) { |
| case SND_SOC_DAIFMT_BC_FC: |
| rdai->clk_master = 0; |
| break; |
| case SND_SOC_DAIFMT_BP_FP: |
| rdai->clk_master = 1; /* cpu is master */ |
| break; |
| default: |
| return -EINVAL; |
| } |
| |
| /* set format */ |
| rdai->bit_clk_inv = 0; |
| switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { |
| case SND_SOC_DAIFMT_I2S: |
| rdai->sys_delay = 0; |
| rdai->data_alignment = 0; |
| rdai->frm_clk_inv = 0; |
| break; |
| case SND_SOC_DAIFMT_LEFT_J: |
| case SND_SOC_DAIFMT_DSP_B: |
| rdai->sys_delay = 1; |
| rdai->data_alignment = 0; |
| rdai->frm_clk_inv = 1; |
| break; |
| case SND_SOC_DAIFMT_RIGHT_J: |
| rdai->sys_delay = 1; |
| rdai->data_alignment = 1; |
| rdai->frm_clk_inv = 1; |
| break; |
| case SND_SOC_DAIFMT_DSP_A: |
| rdai->sys_delay = 0; |
| rdai->data_alignment = 0; |
| rdai->frm_clk_inv = 1; |
| break; |
| } |
| |
| /* set clock inversion */ |
| switch (fmt & SND_SOC_DAIFMT_INV_MASK) { |
| case SND_SOC_DAIFMT_NB_IF: |
| rdai->frm_clk_inv = !rdai->frm_clk_inv; |
| break; |
| case SND_SOC_DAIFMT_IB_NF: |
| rdai->bit_clk_inv = !rdai->bit_clk_inv; |
| break; |
| case SND_SOC_DAIFMT_IB_IF: |
| rdai->bit_clk_inv = !rdai->bit_clk_inv; |
| rdai->frm_clk_inv = !rdai->frm_clk_inv; |
| break; |
| case SND_SOC_DAIFMT_NB_NF: |
| default: |
| break; |
| } |
| |
| return 0; |
| } |
| |
| static int rsnd_soc_set_dai_tdm_slot(struct snd_soc_dai *dai, |
| u32 tx_mask, u32 rx_mask, |
| int slots, int slot_width) |
| { |
| struct rsnd_priv *priv = rsnd_dai_to_priv(dai); |
| struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai); |
| struct device *dev = rsnd_priv_to_dev(priv); |
| |
| switch (slot_width) { |
| case 16: |
| case 24: |
| case 32: |
| break; |
| default: |
| /* use default */ |
| slot_width = 32; |
| } |
| |
| switch (slots) { |
| case 2: |
| /* TDM Split Mode */ |
| case 6: |
| case 8: |
| /* TDM Extend Mode */ |
| rsnd_rdai_channels_set(rdai, slots); |
| rsnd_rdai_ssi_lane_set(rdai, 1); |
| rsnd_rdai_width_set(rdai, slot_width); |
| break; |
| default: |
| dev_err(dev, "unsupported TDM slots (%d)\n", slots); |
| return -EINVAL; |
| } |
| |
| return 0; |
| } |
| |
| static unsigned int rsnd_soc_hw_channels_list[] = { |
| 2, 6, 8, |
| }; |
| |
| static unsigned int rsnd_soc_hw_rate_list[] = { |
| 8000, |
| 11025, |
| 16000, |
| 22050, |
| 32000, |
| 44100, |
| 48000, |
| 64000, |
| 88200, |
| 96000, |
| 176400, |
| 192000, |
| }; |
| |
| static int rsnd_soc_hw_rule(struct rsnd_dai *rdai, |
| unsigned int *list, int list_num, |
| struct snd_interval *baseline, struct snd_interval *iv) |
| { |
| struct snd_interval p; |
| unsigned int rate; |
| int i; |
| |
| snd_interval_any(&p); |
| p.min = UINT_MAX; |
| p.max = 0; |
| |
| for (i = 0; i < list_num; i++) { |
| |
| if (!snd_interval_test(iv, list[i])) |
| continue; |
| |
| rate = rsnd_ssi_clk_query(rdai, |
| baseline->min, list[i], NULL); |
| if (rate > 0) { |
| p.min = min(p.min, list[i]); |
| p.max = max(p.max, list[i]); |
| } |
| |
| rate = rsnd_ssi_clk_query(rdai, |
| baseline->max, list[i], NULL); |
| if (rate > 0) { |
| p.min = min(p.min, list[i]); |
| p.max = max(p.max, list[i]); |
| } |
| } |
| |
| return snd_interval_refine(iv, &p); |
| } |
| |
| static int rsnd_soc_hw_rule_rate(struct snd_pcm_hw_params *params, |
| struct snd_pcm_hw_rule *rule) |
| { |
| struct snd_interval *ic_ = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); |
| struct snd_interval *ir = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); |
| struct snd_interval ic; |
| struct rsnd_dai_stream *io = rule->private; |
| struct rsnd_dai *rdai = rsnd_io_to_rdai(io); |
| |
| /* |
| * possible sampling rate limitation is same as |
| * 2ch if it supports multi ssi |
| * and same as 8ch if TDM 6ch (see rsnd_ssi_config_init()) |
| */ |
| ic = *ic_; |
| ic.min = |
| ic.max = rsnd_runtime_channel_for_ssi_with_params(io, params); |
| |
| return rsnd_soc_hw_rule(rdai, rsnd_soc_hw_rate_list, |
| ARRAY_SIZE(rsnd_soc_hw_rate_list), |
| &ic, ir); |
| } |
| |
| static int rsnd_soc_hw_rule_channels(struct snd_pcm_hw_params *params, |
| struct snd_pcm_hw_rule *rule) |
| { |
| struct snd_interval *ic_ = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); |
| struct snd_interval *ir = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); |
| struct snd_interval ic; |
| struct rsnd_dai_stream *io = rule->private; |
| struct rsnd_dai *rdai = rsnd_io_to_rdai(io); |
| |
| /* |
| * possible sampling rate limitation is same as |
| * 2ch if it supports multi ssi |
| * and same as 8ch if TDM 6ch (see rsnd_ssi_config_init()) |
| */ |
| ic = *ic_; |
| ic.min = |
| ic.max = rsnd_runtime_channel_for_ssi_with_params(io, params); |
| |
| return rsnd_soc_hw_rule(rdai, rsnd_soc_hw_channels_list, |
| ARRAY_SIZE(rsnd_soc_hw_channels_list), |
| ir, &ic); |
| } |
| |
| static const struct snd_pcm_hardware rsnd_pcm_hardware = { |
| .info = SNDRV_PCM_INFO_INTERLEAVED | |
| SNDRV_PCM_INFO_MMAP | |
| SNDRV_PCM_INFO_MMAP_VALID, |
| .buffer_bytes_max = 64 * 1024, |
| .period_bytes_min = 32, |
| .period_bytes_max = 8192, |
| .periods_min = 1, |
| .periods_max = 32, |
| .fifo_size = 256, |
| }; |
| |
| static int rsnd_soc_dai_startup(struct snd_pcm_substream *substream, |
| struct snd_soc_dai *dai) |
| { |
| struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai); |
| struct rsnd_dai_stream *io = rsnd_rdai_to_io(rdai, substream); |
| struct snd_pcm_hw_constraint_list *constraint = &rdai->constraint; |
| struct snd_pcm_runtime *runtime = substream->runtime; |
| unsigned int max_channels = rsnd_rdai_channels_get(rdai); |
| int i; |
| |
| rsnd_dai_stream_init(io, substream); |
| |
| /* |
| * Channel Limitation |
| * It depends on Platform design |
| */ |
| constraint->list = rsnd_soc_hw_channels_list; |
| constraint->count = 0; |
| constraint->mask = 0; |
| |
| for (i = 0; i < ARRAY_SIZE(rsnd_soc_hw_channels_list); i++) { |
| if (rsnd_soc_hw_channels_list[i] > max_channels) |
| break; |
| constraint->count = i + 1; |
| } |
| |
| snd_soc_set_runtime_hwparams(substream, &rsnd_pcm_hardware); |
| |
| snd_pcm_hw_constraint_list(runtime, 0, |
| SNDRV_PCM_HW_PARAM_CHANNELS, constraint); |
| |
| snd_pcm_hw_constraint_integer(runtime, |
| SNDRV_PCM_HW_PARAM_PERIODS); |
| |
| /* |
| * Sampling Rate / Channel Limitation |
| * It depends on Clock Master Mode |
| */ |
| if (rsnd_rdai_is_clk_master(rdai)) { |
| int is_play = substream->stream == SNDRV_PCM_STREAM_PLAYBACK; |
| |
| snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, |
| rsnd_soc_hw_rule_rate, |
| is_play ? &rdai->playback : &rdai->capture, |
| SNDRV_PCM_HW_PARAM_CHANNELS, -1); |
| snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, |
| rsnd_soc_hw_rule_channels, |
| is_play ? &rdai->playback : &rdai->capture, |
| SNDRV_PCM_HW_PARAM_RATE, -1); |
| } |
| |
| return 0; |
| } |
| |
| static void rsnd_soc_dai_shutdown(struct snd_pcm_substream *substream, |
| struct snd_soc_dai *dai) |
| { |
| struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai); |
| struct rsnd_priv *priv = rsnd_rdai_to_priv(rdai); |
| struct rsnd_dai_stream *io = rsnd_rdai_to_io(rdai, substream); |
| |
| /* |
| * call rsnd_dai_call without spinlock |
| */ |
| rsnd_dai_call(cleanup, io, priv); |
| |
| rsnd_dai_stream_quit(io); |
| } |
| |
| static int rsnd_soc_dai_prepare(struct snd_pcm_substream *substream, |
| struct snd_soc_dai *dai) |
| { |
| struct rsnd_priv *priv = rsnd_dai_to_priv(dai); |
| struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai); |
| struct rsnd_dai_stream *io = rsnd_rdai_to_io(rdai, substream); |
| |
| return rsnd_dai_call(prepare, io, priv); |
| } |
| |
| static u64 rsnd_soc_dai_formats[] = { |
| /* |
| * 1st Priority |
| * |
| * Well tested formats. |
| * Select below from Sound Card, not auto |
| * SND_SOC_DAIFMT_CBC_CFC |
| * SND_SOC_DAIFMT_CBP_CFP |
| */ |
| SND_SOC_POSSIBLE_DAIFMT_I2S | |
| SND_SOC_POSSIBLE_DAIFMT_RIGHT_J | |
| SND_SOC_POSSIBLE_DAIFMT_LEFT_J | |
| SND_SOC_POSSIBLE_DAIFMT_NB_NF | |
| SND_SOC_POSSIBLE_DAIFMT_NB_IF | |
| SND_SOC_POSSIBLE_DAIFMT_IB_NF | |
| SND_SOC_POSSIBLE_DAIFMT_IB_IF, |
| /* |
| * 2nd Priority |
| * |
| * Supported, but not well tested |
| */ |
| SND_SOC_POSSIBLE_DAIFMT_DSP_A | |
| SND_SOC_POSSIBLE_DAIFMT_DSP_B, |
| }; |
| |
| static const struct snd_soc_dai_ops rsnd_soc_dai_ops = { |
| .startup = rsnd_soc_dai_startup, |
| .shutdown = rsnd_soc_dai_shutdown, |
| .trigger = rsnd_soc_dai_trigger, |
| .set_fmt = rsnd_soc_dai_set_fmt, |
| .set_tdm_slot = rsnd_soc_set_dai_tdm_slot, |
| .prepare = rsnd_soc_dai_prepare, |
| .auto_selectable_formats = rsnd_soc_dai_formats, |
| .num_auto_selectable_formats = ARRAY_SIZE(rsnd_soc_dai_formats), |
| }; |
| |
| static void rsnd_parse_tdm_split_mode(struct rsnd_priv *priv, |
| struct rsnd_dai_stream *io, |
| struct device_node *dai_np) |
| { |
| struct device *dev = rsnd_priv_to_dev(priv); |
| struct device_node *ssiu_np = rsnd_ssiu_of_node(priv); |
| struct device_node *np; |
| int is_play = rsnd_io_is_play(io); |
| int i; |
| |
| if (!ssiu_np) |
| return; |
| |
| /* |
| * This driver assumes that it is TDM Split mode |
| * if it includes ssiu node |
| */ |
| for (i = 0;; i++) { |
| struct device_node *node = is_play ? |
| of_parse_phandle(dai_np, "playback", i) : |
| of_parse_phandle(dai_np, "capture", i); |
| |
| if (!node) |
| break; |
| |
| for_each_child_of_node(ssiu_np, np) { |
| if (np == node) { |
| rsnd_flags_set(io, RSND_STREAM_TDM_SPLIT); |
| dev_dbg(dev, "%s is part of TDM Split\n", io->name); |
| } |
| } |
| |
| of_node_put(node); |
| } |
| |
| of_node_put(ssiu_np); |
| } |
| |
| static void rsnd_parse_connect_simple(struct rsnd_priv *priv, |
| struct rsnd_dai_stream *io, |
| struct device_node *dai_np) |
| { |
| if (!rsnd_io_to_mod_ssi(io)) |
| return; |
| |
| rsnd_parse_tdm_split_mode(priv, io, dai_np); |
| } |
| |
| static void rsnd_parse_connect_graph(struct rsnd_priv *priv, |
| struct rsnd_dai_stream *io, |
| struct device_node *endpoint) |
| { |
| struct device *dev = rsnd_priv_to_dev(priv); |
| struct device_node *remote_node; |
| |
| if (!rsnd_io_to_mod_ssi(io)) |
| return; |
| |
| remote_node = of_graph_get_remote_port_parent(endpoint); |
| |
| /* HDMI0 */ |
| if (strstr(remote_node->full_name, "hdmi@fead0000")) { |
| rsnd_flags_set(io, RSND_STREAM_HDMI0); |
| dev_dbg(dev, "%s connected to HDMI0\n", io->name); |
| } |
| |
| /* HDMI1 */ |
| if (strstr(remote_node->full_name, "hdmi@feae0000")) { |
| rsnd_flags_set(io, RSND_STREAM_HDMI1); |
| dev_dbg(dev, "%s connected to HDMI1\n", io->name); |
| } |
| |
| rsnd_parse_tdm_split_mode(priv, io, endpoint); |
| |
| of_node_put(remote_node); |
| } |
| |
| void rsnd_parse_connect_common(struct rsnd_dai *rdai, char *name, |
| struct rsnd_mod* (*mod_get)(struct rsnd_priv *priv, int id), |
| struct device_node *node, |
| struct device_node *playback, |
| struct device_node *capture) |
| { |
| struct rsnd_priv *priv = rsnd_rdai_to_priv(rdai); |
| struct device *dev = rsnd_priv_to_dev(priv); |
| struct device_node *np; |
| int i; |
| |
| if (!node) |
| return; |
| |
| i = 0; |
| for_each_child_of_node(node, np) { |
| struct rsnd_mod *mod; |
| |
| i = rsnd_node_fixed_index(dev, np, name, i); |
| if (i < 0) { |
| of_node_put(np); |
| break; |
| } |
| |
| mod = mod_get(priv, i); |
| |
| if (np == playback) |
| rsnd_dai_connect(mod, &rdai->playback, mod->type); |
| if (np == capture) |
| rsnd_dai_connect(mod, &rdai->capture, mod->type); |
| i++; |
| } |
| |
| of_node_put(node); |
| } |
| |
| int rsnd_node_fixed_index(struct device *dev, struct device_node *node, char *name, int idx) |
| { |
| char node_name[16]; |
| |
| /* |
| * rsnd is assuming each device nodes are sequential numbering, |
| * but some of them are not. |
| * This function adjusts index for it. |
| * |
| * ex) |
| * Normal case, special case |
| * ssi-0 |
| * ssi-1 |
| * ssi-2 |
| * ssi-3 ssi-3 |
| * ssi-4 ssi-4 |
| * ... |
| * |
| * assume Max 64 node |
| */ |
| for (; idx < 64; idx++) { |
| snprintf(node_name, sizeof(node_name), "%s-%d", name, idx); |
| |
| if (strncmp(node_name, of_node_full_name(node), sizeof(node_name)) == 0) |
| return idx; |
| } |
| |
| dev_err(dev, "strange node numbering (%s)", |
| of_node_full_name(node)); |
| return -EINVAL; |
| } |
| |
| int rsnd_node_count(struct rsnd_priv *priv, struct device_node *node, char *name) |
| { |
| struct device *dev = rsnd_priv_to_dev(priv); |
| struct device_node *np; |
| int i; |
| |
| i = 0; |
| for_each_child_of_node(node, np) { |
| i = rsnd_node_fixed_index(dev, np, name, i); |
| if (i < 0) { |
| of_node_put(np); |
| return 0; |
| } |
| i++; |
| } |
| |
| return i; |
| } |
| |
| static struct device_node *rsnd_dai_of_node(struct rsnd_priv *priv, |
| int *is_graph) |
| { |
| struct device *dev = rsnd_priv_to_dev(priv); |
| struct device_node *np = dev->of_node; |
| struct device_node *dai_node; |
| struct device_node *ret; |
| |
| *is_graph = 0; |
| |
| /* |
| * parse both previous dai (= rcar_sound,dai), and |
| * graph dai (= ports/port) |
| */ |
| dai_node = of_get_child_by_name(np, RSND_NODE_DAI); |
| if (dai_node) { |
| ret = dai_node; |
| goto of_node_compatible; |
| } |
| |
| ret = np; |
| |
| dai_node = of_graph_get_next_endpoint(np, NULL); |
| if (dai_node) |
| goto of_node_graph; |
| |
| return NULL; |
| |
| of_node_graph: |
| *is_graph = 1; |
| of_node_compatible: |
| of_node_put(dai_node); |
| |
| return ret; |
| } |
| |
| |
| #define PREALLOC_BUFFER (32 * 1024) |
| #define PREALLOC_BUFFER_MAX (32 * 1024) |
| |
| static int rsnd_preallocate_pages(struct snd_soc_pcm_runtime *rtd, |
| struct rsnd_dai_stream *io, |
| int stream) |
| { |
| struct rsnd_priv *priv = rsnd_io_to_priv(io); |
| struct device *dev = rsnd_priv_to_dev(priv); |
| struct snd_pcm_substream *substream; |
| |
| /* |
| * use Audio-DMAC dev if we can use IPMMU |
| * see |
| * rsnd_dmaen_attach() |
| */ |
| if (io->dmac_dev) |
| dev = io->dmac_dev; |
| |
| for (substream = rtd->pcm->streams[stream].substream; |
| substream; |
| substream = substream->next) { |
| snd_pcm_set_managed_buffer(substream, |
| SNDRV_DMA_TYPE_DEV, |
| dev, |
| PREALLOC_BUFFER, PREALLOC_BUFFER_MAX); |
| } |
| |
| return 0; |
| } |
| |
| static int rsnd_pcm_new(struct snd_soc_pcm_runtime *rtd, |
| struct snd_soc_dai *dai) |
| { |
| struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai); |
| int ret; |
| |
| ret = rsnd_dai_call(pcm_new, &rdai->playback, rtd); |
| if (ret) |
| return ret; |
| |
| ret = rsnd_dai_call(pcm_new, &rdai->capture, rtd); |
| if (ret) |
| return ret; |
| |
| ret = rsnd_preallocate_pages(rtd, &rdai->playback, |
| SNDRV_PCM_STREAM_PLAYBACK); |
| if (ret) |
| return ret; |
| |
| ret = rsnd_preallocate_pages(rtd, &rdai->capture, |
| SNDRV_PCM_STREAM_CAPTURE); |
| if (ret) |
| return ret; |
| |
| return 0; |
| } |
| |
| static void __rsnd_dai_probe(struct rsnd_priv *priv, |
| struct device_node *dai_np, |
| int dai_i) |
| { |
| struct rsnd_dai_stream *io_playback; |
| struct rsnd_dai_stream *io_capture; |
| struct snd_soc_dai_driver *drv; |
| struct rsnd_dai *rdai; |
| struct device *dev = rsnd_priv_to_dev(priv); |
| int io_i; |
| |
| rdai = rsnd_rdai_get(priv, dai_i); |
| drv = rsnd_daidrv_get(priv, dai_i); |
| io_playback = &rdai->playback; |
| io_capture = &rdai->capture; |
| |
| snprintf(rdai->name, RSND_DAI_NAME_SIZE, "rsnd-dai.%d", dai_i); |
| |
| rdai->priv = priv; |
| drv->name = rdai->name; |
| drv->ops = &rsnd_soc_dai_ops; |
| drv->pcm_new = rsnd_pcm_new; |
| |
| snprintf(io_playback->name, RSND_DAI_NAME_SIZE, |
| "DAI%d Playback", dai_i); |
| drv->playback.rates = RSND_RATES; |
| drv->playback.formats = RSND_FMTS; |
| drv->playback.channels_min = 2; |
| drv->playback.channels_max = 8; |
| drv->playback.stream_name = io_playback->name; |
| |
| snprintf(io_capture->name, RSND_DAI_NAME_SIZE, |
| "DAI%d Capture", dai_i); |
| drv->capture.rates = RSND_RATES; |
| drv->capture.formats = RSND_FMTS; |
| drv->capture.channels_min = 2; |
| drv->capture.channels_max = 8; |
| drv->capture.stream_name = io_capture->name; |
| |
| io_playback->rdai = rdai; |
| io_capture->rdai = rdai; |
| rsnd_rdai_channels_set(rdai, 2); /* default 2ch */ |
| rsnd_rdai_ssi_lane_set(rdai, 1); /* default 1lane */ |
| rsnd_rdai_width_set(rdai, 32); /* default 32bit width */ |
| |
| for (io_i = 0;; io_i++) { |
| struct device_node *playback = of_parse_phandle(dai_np, "playback", io_i); |
| struct device_node *capture = of_parse_phandle(dai_np, "capture", io_i); |
| |
| if (!playback && !capture) |
| break; |
| |
| rsnd_parse_connect_ssi(rdai, playback, capture); |
| rsnd_parse_connect_ssiu(rdai, playback, capture); |
| rsnd_parse_connect_src(rdai, playback, capture); |
| rsnd_parse_connect_ctu(rdai, playback, capture); |
| rsnd_parse_connect_mix(rdai, playback, capture); |
| rsnd_parse_connect_dvc(rdai, playback, capture); |
| |
| of_node_put(playback); |
| of_node_put(capture); |
| } |
| |
| if (rsnd_ssi_is_pin_sharing(io_capture) || |
| rsnd_ssi_is_pin_sharing(io_playback)) { |
| /* should have symmetric_rate if pin sharing */ |
| drv->symmetric_rate = 1; |
| } |
| |
| dev_dbg(dev, "%s (%s/%s)\n", rdai->name, |
| rsnd_io_to_mod_ssi(io_playback) ? "play" : " -- ", |
| rsnd_io_to_mod_ssi(io_capture) ? "capture" : " -- "); |
| } |
| |
| static int rsnd_dai_probe(struct rsnd_priv *priv) |
| { |
| struct device_node *dai_node; |
| struct device_node *dai_np; |
| struct snd_soc_dai_driver *rdrv; |
| struct device *dev = rsnd_priv_to_dev(priv); |
| struct rsnd_dai *rdai; |
| int nr; |
| int is_graph; |
| int dai_i; |
| |
| dai_node = rsnd_dai_of_node(priv, &is_graph); |
| if (is_graph) |
| nr = of_graph_get_endpoint_count(dai_node); |
| else |
| nr = of_get_child_count(dai_node); |
| |
| if (!nr) |
| return -EINVAL; |
| |
| rdrv = devm_kcalloc(dev, nr, sizeof(*rdrv), GFP_KERNEL); |
| rdai = devm_kcalloc(dev, nr, sizeof(*rdai), GFP_KERNEL); |
| if (!rdrv || !rdai) |
| return -ENOMEM; |
| |
| priv->rdai_nr = nr; |
| priv->daidrv = rdrv; |
| priv->rdai = rdai; |
| |
| /* |
| * parse all dai |
| */ |
| dai_i = 0; |
| if (is_graph) { |
| for_each_endpoint_of_node(dai_node, dai_np) { |
| __rsnd_dai_probe(priv, dai_np, dai_i); |
| if (rsnd_is_gen3(priv)) { |
| rdai = rsnd_rdai_get(priv, dai_i); |
| |
| rsnd_parse_connect_graph(priv, &rdai->playback, dai_np); |
| rsnd_parse_connect_graph(priv, &rdai->capture, dai_np); |
| } |
| dai_i++; |
| } |
| } else { |
| for_each_child_of_node(dai_node, dai_np) { |
| __rsnd_dai_probe(priv, dai_np, dai_i); |
| if (rsnd_is_gen3(priv)) { |
| rdai = rsnd_rdai_get(priv, dai_i); |
| |
| rsnd_parse_connect_simple(priv, &rdai->playback, dai_np); |
| rsnd_parse_connect_simple(priv, &rdai->capture, dai_np); |
| } |
| dai_i++; |
| } |
| } |
| |
| return 0; |
| } |
| |
| /* |
| * pcm ops |
| */ |
| static int rsnd_hw_update(struct snd_pcm_substream *substream, |
| struct snd_pcm_hw_params *hw_params) |
| { |
| struct snd_soc_dai *dai = rsnd_substream_to_dai(substream); |
| struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai); |
| struct rsnd_dai_stream *io = rsnd_rdai_to_io(rdai, substream); |
| struct rsnd_priv *priv = rsnd_io_to_priv(io); |
| unsigned long flags; |
| int ret; |
| |
| spin_lock_irqsave(&priv->lock, flags); |
| if (hw_params) |
| ret = rsnd_dai_call(hw_params, io, substream, hw_params); |
| else |
| ret = rsnd_dai_call(hw_free, io, substream); |
| spin_unlock_irqrestore(&priv->lock, flags); |
| |
| return ret; |
| } |
| |
| static int rsnd_hw_params(struct snd_soc_component *component, |
| struct snd_pcm_substream *substream, |
| struct snd_pcm_hw_params *hw_params) |
| { |
| struct snd_soc_dai *dai = rsnd_substream_to_dai(substream); |
| struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai); |
| struct rsnd_dai_stream *io = rsnd_rdai_to_io(rdai, substream); |
| struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream); |
| |
| /* |
| * rsnd assumes that it might be used under DPCM if user want to use |
| * channel / rate convert. Then, rsnd should be FE. |
| * And then, this function will be called *after* BE settings. |
| * this means, each BE already has fixuped hw_params. |
| * see |
| * dpcm_fe_dai_hw_params() |
| * dpcm_be_dai_hw_params() |
| */ |
| io->converted_rate = 0; |
| io->converted_chan = 0; |
| if (fe->dai_link->dynamic) { |
| struct rsnd_priv *priv = rsnd_io_to_priv(io); |
| struct device *dev = rsnd_priv_to_dev(priv); |
| struct snd_soc_dpcm *dpcm; |
| int stream = substream->stream; |
| |
| for_each_dpcm_be(fe, stream, dpcm) { |
| struct snd_pcm_hw_params *be_params = &dpcm->hw_params; |
| |
| if (params_channels(hw_params) != params_channels(be_params)) |
| io->converted_chan = params_channels(be_params); |
| if (params_rate(hw_params) != params_rate(be_params)) |
| io->converted_rate = params_rate(be_params); |
| } |
| if (io->converted_chan) |
| dev_dbg(dev, "convert channels = %d\n", io->converted_chan); |
| if (io->converted_rate) { |
| /* |
| * SRC supports convert rates from params_rate(hw_params)/k_down |
| * to params_rate(hw_params)*k_up, where k_up is always 6, and |
| * k_down depends on number of channels and SRC unit. |
| * So all SRC units can upsample audio up to 6 times regardless |
| * its number of channels. And all SRC units can downsample |
| * 2 channel audio up to 6 times too. |
| */ |
| int k_up = 6; |
| int k_down = 6; |
| int channel; |
| struct rsnd_mod *src_mod = rsnd_io_to_mod_src(io); |
| |
| dev_dbg(dev, "convert rate = %d\n", io->converted_rate); |
| |
| channel = io->converted_chan ? io->converted_chan : |
| params_channels(hw_params); |
| |
| switch (rsnd_mod_id(src_mod)) { |
| /* |
| * SRC0 can downsample 4, 6 and 8 channel audio up to 4 times. |
| * SRC1, SRC3 and SRC4 can downsample 4 channel audio |
| * up to 4 times. |
| * SRC1, SRC3 and SRC4 can downsample 6 and 8 channel audio |
| * no more than twice. |
| */ |
| case 1: |
| case 3: |
| case 4: |
| if (channel > 4) { |
| k_down = 2; |
| break; |
| } |
| fallthrough; |
| case 0: |
| if (channel > 2) |
| k_down = 4; |
| break; |
| |
| /* Other SRC units do not support more than 2 channels */ |
| default: |
| if (channel > 2) |
| return -EINVAL; |
| } |
| |
| if (params_rate(hw_params) > io->converted_rate * k_down) { |
| hw_param_interval(hw_params, SNDRV_PCM_HW_PARAM_RATE)->min = |
| io->converted_rate * k_down; |
| hw_param_interval(hw_params, SNDRV_PCM_HW_PARAM_RATE)->max = |
| io->converted_rate * k_down; |
| hw_params->cmask |= SNDRV_PCM_HW_PARAM_RATE; |
| } else if (params_rate(hw_params) * k_up < io->converted_rate) { |
| hw_param_interval(hw_params, SNDRV_PCM_HW_PARAM_RATE)->min = |
| (io->converted_rate + k_up - 1) / k_up; |
| hw_param_interval(hw_params, SNDRV_PCM_HW_PARAM_RATE)->max = |
| (io->converted_rate + k_up - 1) / k_up; |
| hw_params->cmask |= SNDRV_PCM_HW_PARAM_RATE; |
| } |
| |
| /* |
| * TBD: Max SRC input and output rates also depend on number |
| * of channels and SRC unit: |
| * SRC1, SRC3 and SRC4 do not support more than 128kHz |
| * for 6 channel and 96kHz for 8 channel audio. |
| * Perhaps this function should return EINVAL if the input or |
| * the output rate exceeds the limitation. |
| */ |
| } |
| } |
| |
| return rsnd_hw_update(substream, hw_params); |
| } |
| |
| static int rsnd_hw_free(struct snd_soc_component *component, |
| struct snd_pcm_substream *substream) |
| { |
| return rsnd_hw_update(substream, NULL); |
| } |
| |
| static snd_pcm_uframes_t rsnd_pointer(struct snd_soc_component *component, |
| struct snd_pcm_substream *substream) |
| { |
| struct snd_soc_dai *dai = rsnd_substream_to_dai(substream); |
| struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai); |
| struct rsnd_dai_stream *io = rsnd_rdai_to_io(rdai, substream); |
| snd_pcm_uframes_t pointer = 0; |
| |
| rsnd_dai_call(pointer, io, &pointer); |
| |
| return pointer; |
| } |
| |
| /* |
| * snd_kcontrol |
| */ |
| static int rsnd_kctrl_info(struct snd_kcontrol *kctrl, |
| struct snd_ctl_elem_info *uinfo) |
| { |
| struct rsnd_kctrl_cfg *cfg = snd_kcontrol_chip(kctrl); |
| |
| if (cfg->texts) { |
| uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; |
| uinfo->count = cfg->size; |
| uinfo->value.enumerated.items = cfg->max; |
| if (uinfo->value.enumerated.item >= cfg->max) |
| uinfo->value.enumerated.item = cfg->max - 1; |
| strscpy(uinfo->value.enumerated.name, |
| cfg->texts[uinfo->value.enumerated.item], |
| sizeof(uinfo->value.enumerated.name)); |
| } else { |
| uinfo->count = cfg->size; |
| uinfo->value.integer.min = 0; |
| uinfo->value.integer.max = cfg->max; |
| uinfo->type = (cfg->max == 1) ? |
| SNDRV_CTL_ELEM_TYPE_BOOLEAN : |
| SNDRV_CTL_ELEM_TYPE_INTEGER; |
| } |
| |
| return 0; |
| } |
| |
| static int rsnd_kctrl_get(struct snd_kcontrol *kctrl, |
| struct snd_ctl_elem_value *uc) |
| { |
| struct rsnd_kctrl_cfg *cfg = snd_kcontrol_chip(kctrl); |
| int i; |
| |
| for (i = 0; i < cfg->size; i++) |
| if (cfg->texts) |
| uc->value.enumerated.item[i] = cfg->val[i]; |
| else |
| uc->value.integer.value[i] = cfg->val[i]; |
| |
| return 0; |
| } |
| |
| static int rsnd_kctrl_put(struct snd_kcontrol *kctrl, |
| struct snd_ctl_elem_value *uc) |
| { |
| struct rsnd_kctrl_cfg *cfg = snd_kcontrol_chip(kctrl); |
| int i, change = 0; |
| |
| if (!cfg->accept(cfg->io)) |
| return 0; |
| |
| for (i = 0; i < cfg->size; i++) { |
| if (cfg->texts) { |
| change |= (uc->value.enumerated.item[i] != cfg->val[i]); |
| cfg->val[i] = uc->value.enumerated.item[i]; |
| } else { |
| change |= (uc->value.integer.value[i] != cfg->val[i]); |
| cfg->val[i] = uc->value.integer.value[i]; |
| } |
| } |
| |
| if (change && cfg->update) |
| cfg->update(cfg->io, cfg->mod); |
| |
| return change; |
| } |
| |
| int rsnd_kctrl_accept_anytime(struct rsnd_dai_stream *io) |
| { |
| return 1; |
| } |
| |
| int rsnd_kctrl_accept_runtime(struct rsnd_dai_stream *io) |
| { |
| struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); |
| struct rsnd_priv *priv = rsnd_io_to_priv(io); |
| struct device *dev = rsnd_priv_to_dev(priv); |
| |
| if (!runtime) { |
| dev_warn(dev, "Can't update kctrl when idle\n"); |
| return 0; |
| } |
| |
| return 1; |
| } |
| |
| struct rsnd_kctrl_cfg *rsnd_kctrl_init_m(struct rsnd_kctrl_cfg_m *cfg) |
| { |
| cfg->cfg.val = cfg->val; |
| |
| return &cfg->cfg; |
| } |
| |
| struct rsnd_kctrl_cfg *rsnd_kctrl_init_s(struct rsnd_kctrl_cfg_s *cfg) |
| { |
| cfg->cfg.val = &cfg->val; |
| |
| return &cfg->cfg; |
| } |
| |
| const char * const volume_ramp_rate[] = { |
| "128 dB/1 step", /* 00000 */ |
| "64 dB/1 step", /* 00001 */ |
| "32 dB/1 step", /* 00010 */ |
| "16 dB/1 step", /* 00011 */ |
| "8 dB/1 step", /* 00100 */ |
| "4 dB/1 step", /* 00101 */ |
| "2 dB/1 step", /* 00110 */ |
| "1 dB/1 step", /* 00111 */ |
| "0.5 dB/1 step", /* 01000 */ |
| "0.25 dB/1 step", /* 01001 */ |
| "0.125 dB/1 step", /* 01010 = VOLUME_RAMP_MAX_MIX */ |
| "0.125 dB/2 steps", /* 01011 */ |
| "0.125 dB/4 steps", /* 01100 */ |
| "0.125 dB/8 steps", /* 01101 */ |
| "0.125 dB/16 steps", /* 01110 */ |
| "0.125 dB/32 steps", /* 01111 */ |
| "0.125 dB/64 steps", /* 10000 */ |
| "0.125 dB/128 steps", /* 10001 */ |
| "0.125 dB/256 steps", /* 10010 */ |
| "0.125 dB/512 steps", /* 10011 */ |
| "0.125 dB/1024 steps", /* 10100 */ |
| "0.125 dB/2048 steps", /* 10101 */ |
| "0.125 dB/4096 steps", /* 10110 */ |
| "0.125 dB/8192 steps", /* 10111 = VOLUME_RAMP_MAX_DVC */ |
| }; |
| |
| int rsnd_kctrl_new(struct rsnd_mod *mod, |
| struct rsnd_dai_stream *io, |
| struct snd_soc_pcm_runtime *rtd, |
| const unsigned char *name, |
| int (*accept)(struct rsnd_dai_stream *io), |
| void (*update)(struct rsnd_dai_stream *io, |
| struct rsnd_mod *mod), |
| struct rsnd_kctrl_cfg *cfg, |
| const char * const *texts, |
| int size, |
| u32 max) |
| { |
| struct snd_card *card = rtd->card->snd_card; |
| struct snd_kcontrol *kctrl; |
| struct snd_kcontrol_new knew = { |
| .iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
| .name = name, |
| .info = rsnd_kctrl_info, |
| .index = rtd->num, |
| .get = rsnd_kctrl_get, |
| .put = rsnd_kctrl_put, |
| }; |
| int ret; |
| |
| /* |
| * 1) Avoid duplicate register for DVC with MIX case |
| * 2) Allow duplicate register for MIX |
| * 3) re-register if card was rebinded |
| */ |
| list_for_each_entry(kctrl, &card->controls, list) { |
| struct rsnd_kctrl_cfg *c = kctrl->private_data; |
| |
| if (c == cfg) |
| return 0; |
| } |
| |
| if (size > RSND_MAX_CHANNELS) |
| return -EINVAL; |
| |
| kctrl = snd_ctl_new1(&knew, cfg); |
| if (!kctrl) |
| return -ENOMEM; |
| |
| ret = snd_ctl_add(card, kctrl); |
| if (ret < 0) |
| return ret; |
| |
| cfg->texts = texts; |
| cfg->max = max; |
| cfg->size = size; |
| cfg->accept = accept; |
| cfg->update = update; |
| cfg->card = card; |
| cfg->kctrl = kctrl; |
| cfg->io = io; |
| cfg->mod = mod; |
| |
| return 0; |
| } |
| |
| /* |
| * snd_soc_component |
| */ |
| static const struct snd_soc_component_driver rsnd_soc_component = { |
| .name = "rsnd", |
| .probe = rsnd_debugfs_probe, |
| .hw_params = rsnd_hw_params, |
| .hw_free = rsnd_hw_free, |
| .pointer = rsnd_pointer, |
| .legacy_dai_naming = 1, |
| }; |
| |
| static int rsnd_rdai_continuance_probe(struct rsnd_priv *priv, |
| struct rsnd_dai_stream *io) |
| { |
| int ret; |
| |
| ret = rsnd_dai_call(probe, io, priv); |
| if (ret == -EAGAIN) { |
| struct rsnd_mod *ssi_mod = rsnd_io_to_mod_ssi(io); |
| struct rsnd_mod *mod; |
| int i; |
| |
| /* |
| * Fallback to PIO mode |
| */ |
| |
| /* |
| * call "remove" for SSI/SRC/DVC |
| * SSI will be switch to PIO mode if it was DMA mode |
| * see |
| * rsnd_dma_init() |
| * rsnd_ssi_fallback() |
| */ |
| rsnd_dai_call(remove, io, priv); |
| |
| /* |
| * remove all mod from io |
| * and, re connect ssi |
| */ |
| for_each_rsnd_mod(i, mod, io) |
| rsnd_dai_disconnect(mod, io, i); |
| rsnd_dai_connect(ssi_mod, io, RSND_MOD_SSI); |
| |
| /* |
| * fallback |
| */ |
| rsnd_dai_call(fallback, io, priv); |
| |
| /* |
| * retry to "probe". |
| * DAI has SSI which is PIO mode only now. |
| */ |
| ret = rsnd_dai_call(probe, io, priv); |
| } |
| |
| return ret; |
| } |
| |
| /* |
| * rsnd probe |
| */ |
| static int rsnd_probe(struct platform_device *pdev) |
| { |
| struct rsnd_priv *priv; |
| struct device *dev = &pdev->dev; |
| struct rsnd_dai *rdai; |
| int (*probe_func[])(struct rsnd_priv *priv) = { |
| rsnd_gen_probe, |
| rsnd_dma_probe, |
| rsnd_ssi_probe, |
| rsnd_ssiu_probe, |
| rsnd_src_probe, |
| rsnd_ctu_probe, |
| rsnd_mix_probe, |
| rsnd_dvc_probe, |
| rsnd_cmd_probe, |
| rsnd_adg_probe, |
| rsnd_dai_probe, |
| }; |
| int ret, i; |
| |
| /* |
| * init priv data |
| */ |
| priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); |
| if (!priv) |
| return -ENODEV; |
| |
| priv->pdev = pdev; |
| priv->flags = (unsigned long)of_device_get_match_data(dev); |
| spin_lock_init(&priv->lock); |
| |
| /* |
| * init each module |
| */ |
| for (i = 0; i < ARRAY_SIZE(probe_func); i++) { |
| ret = probe_func[i](priv); |
| if (ret) |
| return ret; |
| } |
| |
| for_each_rsnd_dai(rdai, priv, i) { |
| ret = rsnd_rdai_continuance_probe(priv, &rdai->playback); |
| if (ret) |
| goto exit_snd_probe; |
| |
| ret = rsnd_rdai_continuance_probe(priv, &rdai->capture); |
| if (ret) |
| goto exit_snd_probe; |
| } |
| |
| dev_set_drvdata(dev, priv); |
| |
| /* |
| * asoc register |
| */ |
| ret = devm_snd_soc_register_component(dev, &rsnd_soc_component, |
| priv->daidrv, rsnd_rdai_nr(priv)); |
| if (ret < 0) { |
| dev_err(dev, "cannot snd dai register\n"); |
| goto exit_snd_probe; |
| } |
| |
| pm_runtime_enable(dev); |
| |
| dev_info(dev, "probed\n"); |
| return ret; |
| |
| exit_snd_probe: |
| for_each_rsnd_dai(rdai, priv, i) { |
| rsnd_dai_call(remove, &rdai->playback, priv); |
| rsnd_dai_call(remove, &rdai->capture, priv); |
| } |
| |
| /* |
| * adg is very special mod which can't use rsnd_dai_call(remove), |
| * and it registers ADG clock on probe. |
| * It should be unregister if probe failed. |
| * Mainly it is assuming -EPROBE_DEFER case |
| */ |
| rsnd_adg_remove(priv); |
| |
| return ret; |
| } |
| |
| static int rsnd_remove(struct platform_device *pdev) |
| { |
| struct rsnd_priv *priv = dev_get_drvdata(&pdev->dev); |
| struct rsnd_dai *rdai; |
| void (*remove_func[])(struct rsnd_priv *priv) = { |
| rsnd_ssi_remove, |
| rsnd_ssiu_remove, |
| rsnd_src_remove, |
| rsnd_ctu_remove, |
| rsnd_mix_remove, |
| rsnd_dvc_remove, |
| rsnd_cmd_remove, |
| rsnd_adg_remove, |
| }; |
| int i; |
| |
| pm_runtime_disable(&pdev->dev); |
| |
| for_each_rsnd_dai(rdai, priv, i) { |
| int ret; |
| |
| ret = rsnd_dai_call(remove, &rdai->playback, priv); |
| if (ret) |
| dev_warn(&pdev->dev, "Failed to remove playback dai #%d\n", i); |
| |
| ret = rsnd_dai_call(remove, &rdai->capture, priv); |
| if (ret) |
| dev_warn(&pdev->dev, "Failed to remove capture dai #%d\n", i); |
| } |
| |
| for (i = 0; i < ARRAY_SIZE(remove_func); i++) |
| remove_func[i](priv); |
| |
| return 0; |
| } |
| |
| static int __maybe_unused rsnd_suspend(struct device *dev) |
| { |
| struct rsnd_priv *priv = dev_get_drvdata(dev); |
| |
| rsnd_adg_clk_disable(priv); |
| |
| return 0; |
| } |
| |
| static int __maybe_unused rsnd_resume(struct device *dev) |
| { |
| struct rsnd_priv *priv = dev_get_drvdata(dev); |
| |
| rsnd_adg_clk_enable(priv); |
| |
| return 0; |
| } |
| |
| static const struct dev_pm_ops rsnd_pm_ops = { |
| SET_SYSTEM_SLEEP_PM_OPS(rsnd_suspend, rsnd_resume) |
| }; |
| |
| static struct platform_driver rsnd_driver = { |
| .driver = { |
| .name = "rcar_sound", |
| .pm = &rsnd_pm_ops, |
| .of_match_table = rsnd_of_match, |
| }, |
| .probe = rsnd_probe, |
| .remove = rsnd_remove, |
| }; |
| module_platform_driver(rsnd_driver); |
| |
| MODULE_LICENSE("GPL v2"); |
| MODULE_DESCRIPTION("Renesas R-Car audio driver"); |
| MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>"); |
| MODULE_ALIAS("platform:rcar-pcm-audio"); |