select SND_SOC_AK4104 if SPI_MASTER
select SND_SOC_AK4535 if I2C
select SND_SOC_AK4554
+ select SND_SOC_AK4613 if I2C
select SND_SOC_AK4641 if I2C
select SND_SOC_AK4642 if I2C
select SND_SOC_AK4671 if I2C
select SND_SOC_CS4271_SPI if SPI_MASTER
select SND_SOC_CS42XX8_I2C if I2C
select SND_SOC_CS4349 if I2C
+++++ select SND_SOC_CS47L24 if MFD_CS47L24
select SND_SOC_CX20442 if TTY
select SND_SOC_DA7210 if SND_SOC_I2C_AND_SPI
select SND_SOC_DA7213 if I2C
+++++ select SND_SOC_DA7218 if I2C
+ select SND_SOC_DA7219 if I2C
select SND_SOC_DA732X if I2C
select SND_SOC_DA9055 if I2C
select SND_SOC_DMIC
select SND_SOC_ES8328_SPI if SPI_MASTER
select SND_SOC_ES8328_I2C if I2C
select SND_SOC_GTM601
+++++ select SND_SOC_HDAC_HDMI
select SND_SOC_ICS43432
++++ + select SND_SOC_INNO_RK3036
select SND_SOC_ISABELLE if I2C
select SND_SOC_JZ4740_CODEC
select SND_SOC_LM4857 if I2C
select SND_SOC_MAX9877 if I2C
select SND_SOC_MC13783 if MFD_MC13XXX
select SND_SOC_ML26124 if I2C
- select SND_SOC_HDMI_CODEC
+ select SND_SOC_NAU8825 if I2C
select SND_SOC_PCM1681 if I2C
select SND_SOC_PCM1792A if SPI_MASTER
select SND_SOC_PCM3008
+++++ select SND_SOC_PCM3168A_I2C if I2C
+++++ select SND_SOC_PCM3168A_SPI if SPI_MASTER
select SND_SOC_PCM512x_I2C if I2C
select SND_SOC_PCM512x_SPI if SPI_MASTER
select SND_SOC_RT286 if I2C
select SND_SOC_WM8995 if SND_SOC_I2C_AND_SPI
select SND_SOC_WM8996 if I2C
select SND_SOC_WM8997 if MFD_WM8997
+ select SND_SOC_WM8998 if MFD_WM8998
select SND_SOC_WM9081 if I2C
select SND_SOC_WM9090 if I2C
select SND_SOC_WM9705 if SND_SOC_AC97_BUS
config SND_SOC_ARIZONA
tristate
+++++ default y if SND_SOC_CS47L24=y
default y if SND_SOC_WM5102=y
default y if SND_SOC_WM5110=y
default y if SND_SOC_WM8997=y
+ default y if SND_SOC_WM8998=y
+++++ default m if SND_SOC_CS47L24=m
default m if SND_SOC_WM5102=m
default m if SND_SOC_WM5110=m
default m if SND_SOC_WM8997=m
+ default m if SND_SOC_WM8998=m
config SND_SOC_WM_HUBS
tristate
config SND_SOC_WM_ADSP
tristate
+++++ select SND_SOC_COMPRESS
+++++ default y if SND_SOC_CS47L24=y
default y if SND_SOC_WM5102=y
default y if SND_SOC_WM5110=y
default y if SND_SOC_WM2200=y
+++++ default m if SND_SOC_CS47L24=m
default m if SND_SOC_WM5102=m
default m if SND_SOC_WM5110=m
default m if SND_SOC_WM2200=m
config SND_SOC_AK4554
tristate "AKM AK4554 CODEC"
+ config SND_SOC_AK4613
+ tristate "AKM AK4613 CODEC"
+ depends on I2C
+
config SND_SOC_AK4641
tristate
tristate "Cirrus Logic CS4349 CODEC"
depends on I2C
+++++config SND_SOC_CS47L24
+++++ tristate
+++++
config SND_SOC_CX20442
tristate
depends on TTY
config SND_SOC_DA7213
tristate
+++++config SND_SOC_DA7218
+++++ tristate
+++++
+ config SND_SOC_DA7219
+ tristate
+
config SND_SOC_DA732X
tristate
config SND_SOC_DMIC
tristate
- config SND_SOC_HDMI_CODEC
- tristate "HDMI stub CODEC"
-
config SND_SOC_ES8328
tristate "Everest Semi ES8328 CODEC"
config SND_SOC_GTM601
tristate 'GTM601 UMTS modem audio codec'
+++++config SND_SOC_HDAC_HDMI
+++++ tristate
+++++ select SND_HDA_EXT_CORE
+++++ select HDMI
+++++
config SND_SOC_ICS43432
tristate
++++ +config SND_SOC_INNO_RK3036
++++ + tristate "Inno codec driver for RK3036 SoC"
++++ +
config SND_SOC_ISABELLE
tristate
config SND_SOC_PCM3008
tristate
+++++config SND_SOC_PCM3168A
+++++ tristate
+++++
+++++config SND_SOC_PCM3168A_I2C
+++++ tristate "Texas Instruments PCM3168A CODEC - I2C"
+++++ depends on I2C
+++++ select SND_SOC_PCM3168A
+++++ select REGMAP_I2C
+++++
+++++config SND_SOC_PCM3168A_SPI
+++++ tristate "Texas Instruments PCM3168A CODEC - SPI"
+++++ depends on SPI_MASTER
+++++ select SND_SOC_PCM3168A
+++++ select REGMAP_SPI
+++++
config SND_SOC_PCM512x
tristate
config SND_SOC_WM8997
tristate
+ config SND_SOC_WM8998
+ tristate
+
config SND_SOC_WM9081
tristate
config SND_SOC_ML26124
tristate
+ config SND_SOC_NAU8825
+ tristate
+
config SND_SOC_TPA6130A2
tristate "Texas Instruments TPA6130A2 headphone amplifier"
depends on I2C
snd-soc-ak4104-objs := ak4104.o
snd-soc-ak4535-objs := ak4535.o
snd-soc-ak4554-objs := ak4554.o
+ snd-soc-ak4613-objs := ak4613.o
snd-soc-ak4641-objs := ak4641.o
snd-soc-ak4642-objs := ak4642.o
snd-soc-ak4671-objs := ak4671.o
snd-soc-cs42xx8-objs := cs42xx8.o
snd-soc-cs42xx8-i2c-objs := cs42xx8-i2c.o
snd-soc-cs4349-objs := cs4349.o
+++++snd-soc-cs47l24-objs := cs47l24.o
snd-soc-cx20442-objs := cx20442.o
snd-soc-da7210-objs := da7210.o
snd-soc-da7213-objs := da7213.o
+++++snd-soc-da7218-objs := da7218.o
+ snd-soc-da7219-objs := da7219.o da7219-aad.o
snd-soc-da732x-objs := da732x.o
snd-soc-da9055-objs := da9055.o
snd-soc-bt-sco-objs := bt-sco.o
snd-soc-es8328-i2c-objs := es8328-i2c.o
snd-soc-es8328-spi-objs := es8328-spi.o
snd-soc-gtm601-objs := gtm601.o
+++++snd-soc-hdac-hdmi-objs := hdac_hdmi.o
snd-soc-ics43432-objs := ics43432.o
++++ +snd-soc-inno-rk3036-objs := inno_rk3036.o
snd-soc-isabelle-objs := isabelle.o
snd-soc-jz4740-codec-objs := jz4740.o
snd-soc-l3-objs := l3.o
snd-soc-max9850-objs := max9850.o
snd-soc-mc13783-objs := mc13783.o
snd-soc-ml26124-objs := ml26124.o
- snd-soc-hdmi-codec-objs := hdmi.o
+ snd-soc-nau8825-objs := nau8825.o
snd-soc-pcm1681-objs := pcm1681.o
snd-soc-pcm1792a-codec-objs := pcm1792a.o
snd-soc-pcm3008-objs := pcm3008.o
+++++snd-soc-pcm3168a-objs := pcm3168a.o
+++++snd-soc-pcm3168a-i2c-objs := pcm3168a-i2c.o
+++++snd-soc-pcm3168a-spi-objs := pcm3168a-spi.o
snd-soc-pcm512x-objs := pcm512x.o
snd-soc-pcm512x-i2c-objs := pcm512x-i2c.o
snd-soc-pcm512x-spi-objs := pcm512x-spi.o
snd-soc-wm8994-objs := wm8994.o wm8958-dsp2.o
snd-soc-wm8995-objs := wm8995.o
snd-soc-wm8997-objs := wm8997.o
+ snd-soc-wm8998-objs := wm8998.o
snd-soc-wm9081-objs := wm9081.o
snd-soc-wm9090-objs := wm9090.o
snd-soc-wm9705-objs := wm9705.o
obj-$(CONFIG_SND_SOC_AK4104) += snd-soc-ak4104.o
obj-$(CONFIG_SND_SOC_AK4535) += snd-soc-ak4535.o
obj-$(CONFIG_SND_SOC_AK4554) += snd-soc-ak4554.o
+ obj-$(CONFIG_SND_SOC_AK4613) += snd-soc-ak4613.o
obj-$(CONFIG_SND_SOC_AK4641) += snd-soc-ak4641.o
obj-$(CONFIG_SND_SOC_AK4642) += snd-soc-ak4642.o
obj-$(CONFIG_SND_SOC_AK4671) += snd-soc-ak4671.o
obj-$(CONFIG_SND_SOC_CS42XX8) += snd-soc-cs42xx8.o
obj-$(CONFIG_SND_SOC_CS42XX8_I2C) += snd-soc-cs42xx8-i2c.o
obj-$(CONFIG_SND_SOC_CS4349) += snd-soc-cs4349.o
+++++obj-$(CONFIG_SND_SOC_CS47L24) += snd-soc-cs47l24.o
obj-$(CONFIG_SND_SOC_CX20442) += snd-soc-cx20442.o
obj-$(CONFIG_SND_SOC_DA7210) += snd-soc-da7210.o
obj-$(CONFIG_SND_SOC_DA7213) += snd-soc-da7213.o
+++++obj-$(CONFIG_SND_SOC_DA7218) += snd-soc-da7218.o
+ obj-$(CONFIG_SND_SOC_DA7219) += snd-soc-da7219.o
obj-$(CONFIG_SND_SOC_DA732X) += snd-soc-da732x.o
obj-$(CONFIG_SND_SOC_DA9055) += snd-soc-da9055.o
obj-$(CONFIG_SND_SOC_BT_SCO) += snd-soc-bt-sco.o
obj-$(CONFIG_SND_SOC_ES8328_I2C)+= snd-soc-es8328-i2c.o
obj-$(CONFIG_SND_SOC_ES8328_SPI)+= snd-soc-es8328-spi.o
obj-$(CONFIG_SND_SOC_GTM601) += snd-soc-gtm601.o
+++++obj-$(CONFIG_SND_SOC_HDAC_HDMI) += snd-soc-hdac-hdmi.o
obj-$(CONFIG_SND_SOC_ICS43432) += snd-soc-ics43432.o
++++ +obj-$(CONFIG_SND_SOC_INNO_RK3036) += snd-soc-inno-rk3036.o
obj-$(CONFIG_SND_SOC_ISABELLE) += snd-soc-isabelle.o
obj-$(CONFIG_SND_SOC_JZ4740_CODEC) += snd-soc-jz4740-codec.o
obj-$(CONFIG_SND_SOC_L3) += snd-soc-l3.o
obj-$(CONFIG_SND_SOC_MAX9850) += snd-soc-max9850.o
obj-$(CONFIG_SND_SOC_MC13783) += snd-soc-mc13783.o
obj-$(CONFIG_SND_SOC_ML26124) += snd-soc-ml26124.o
- obj-$(CONFIG_SND_SOC_HDMI_CODEC) += snd-soc-hdmi-codec.o
+ obj-$(CONFIG_SND_SOC_NAU8825) += snd-soc-nau8825.o
obj-$(CONFIG_SND_SOC_PCM1681) += snd-soc-pcm1681.o
obj-$(CONFIG_SND_SOC_PCM1792A) += snd-soc-pcm1792a-codec.o
obj-$(CONFIG_SND_SOC_PCM3008) += snd-soc-pcm3008.o
+++++obj-$(CONFIG_SND_SOC_PCM3168A) += snd-soc-pcm3168a.o
+++++obj-$(CONFIG_SND_SOC_PCM3168A_I2C) += snd-soc-pcm3168a-i2c.o
+++++obj-$(CONFIG_SND_SOC_PCM3168A_SPI) += snd-soc-pcm3168a-spi.o
obj-$(CONFIG_SND_SOC_PCM512x) += snd-soc-pcm512x.o
obj-$(CONFIG_SND_SOC_PCM512x_I2C) += snd-soc-pcm512x-i2c.o
obj-$(CONFIG_SND_SOC_PCM512x_SPI) += snd-soc-pcm512x-spi.o
obj-$(CONFIG_SND_SOC_WM8994) += snd-soc-wm8994.o
obj-$(CONFIG_SND_SOC_WM8995) += snd-soc-wm8995.o
obj-$(CONFIG_SND_SOC_WM8997) += snd-soc-wm8997.o
+ obj-$(CONFIG_SND_SOC_WM8998) += snd-soc-wm8998.o
obj-$(CONFIG_SND_SOC_WM9081) += snd-soc-wm9081.o
obj-$(CONFIG_SND_SOC_WM9090) += snd-soc-wm9090.o
obj-$(CONFIG_SND_SOC_WM9705) += snd-soc-wm9705.o
#define RSND_RATES SNDRV_PCM_RATE_8000_96000
#define RSND_FMTS (SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S16_LE)
--- --static const struct rsnd_of_data rsnd_of_data_gen1 = {
--- -- .flags = RSND_GEN1,
--- --};
--- --
--- --static const struct rsnd_of_data rsnd_of_data_gen2 = {
--- -- .flags = RSND_GEN2,
--- --};
--- --
static const struct of_device_id rsnd_of_match[] = {
--- -- { .compatible = "renesas,rcar_sound-gen1", .data = &rsnd_of_data_gen1 },
--- -- { .compatible = "renesas,rcar_sound-gen2", .data = &rsnd_of_data_gen2 },
-- -- { .compatible = "renesas,rcar_sound-gen3", .data = &rsnd_of_data_gen2 }, /* gen2 compatible */
+++ ++ { .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_GEN2 }, /* gen2 compatible */
{},
};
MODULE_DEVICE_TABLE(of, rsnd_of_match);
/*
--- -- * rsnd_platform functions
+++ ++ * rsnd_mod functions
*/
--- --#define rsnd_platform_call(priv, dai, func, param...) \
--- -- (!(priv->info->func) ? 0 : \
--- -- priv->info->func(param))
-- --
-- --#define rsnd_is_enable_path(io, name) \
-- -- ((io)->info ? (io)->info->name : NULL)
-- --#define rsnd_info_id(priv, io, name) \
-- -- ((io)->info->name - priv->info->name##_info)
-- --
+ 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);
- #define rsnd_is_enable_path(io, name) \
- ((io)->info ? (io)->info->name : NULL)
- #define rsnd_info_id(priv, io, name) \
- ((io)->info->name - priv->info->name##_info)
+ dev_warn(dev, "%s[%d] is not your expected module\n",
+ rsnd_mod_name(mod), rsnd_mod_id(mod));
+ }
+ }
--- --/*
--- -- * rsnd_mod functions
--- -- */
char *rsnd_mod_name(struct rsnd_mod *mod)
{
if (!mod || !mod->ops)
struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
struct rsnd_dai_stream *io;
struct rsnd_dai *rdai;
--- -- int i, j;
--- --
--- -- for_each_rsnd_dai(rdai, priv, j) {
+++ ++ int i;
--- -- for (i = 0; i < RSND_MOD_MAX; i++) {
--- -- io = &rdai->playback;
--- -- if (mod == io->mod[i])
--- -- callback(mod, io);
+++ ++ for_each_rsnd_dai(rdai, priv, i) {
+++ ++ io = &rdai->playback;
+++ ++ if (mod == io->mod[mod->type])
+++ ++ callback(mod, io);
--- -- io = &rdai->capture;
--- -- if (mod == io->mod[i])
--- -- callback(mod, io);
--- -- }
+++ ++ io = &rdai->capture;
+++ ++ if (mod == io->mod[mod->type])
+++ ++ callback(mod, io);
}
}
return !!io->substream;
}
+++ ++void rsnd_set_slot(struct rsnd_dai *rdai,
+++ ++ int slots, int num)
+++ ++{
+++ ++ rdai->slots = slots;
+++ ++ rdai->slots_num = num;
+++ ++}
+++ ++
+++ ++int rsnd_get_slot(struct rsnd_dai_stream *io)
+++ ++{
+++ ++ struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
+++ ++
+++ ++ return rdai->slots;
+++ ++}
+++ ++
+++ ++int rsnd_get_slot_num(struct rsnd_dai_stream *io)
+++ ++{
+++ ++ struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
+++ ++
+++ ++ return rdai->slots_num;
+++ ++}
+++ ++
+++ ++int rsnd_get_slot_width(struct rsnd_dai_stream *io)
+++ ++{
+++ ++ struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
+++ ++ int chan = runtime->channels;
+++ ++
+++ ++ /* Multi channel Mode */
+++ ++ if (rsnd_ssi_multi_slaves(io))
+++ ++ chan /= rsnd_get_slot_num(io);
+++ ++
+++ ++ /* TDM Extend Mode needs 8ch */
+++ ++ if (chan == 6)
+++ ++ chan = 8;
+++ ++
+++ ++ return chan;
+++ ++}
+++ ++
/*
* ADINR function
*/
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);
--- -- u32 adinr = runtime->channels;
switch (runtime->sample_bits) {
case 16:
--- -- adinr |= (8 << 16);
--- -- break;
+++ ++ return 8 << 16;
case 32:
--- -- adinr |= (0 << 16);
--- -- break;
--- -- default:
--- -- dev_warn(dev, "not supported sample bits\n");
--- -- return 0;
+++ ++ return 0 << 16;
}
--- -- return adinr;
+++ ++ dev_warn(dev, "not supported sample bits\n");
+++ ++
+++ ++ return 0;
}
u32 rsnd_get_adinr_chan(struct rsnd_mod *mod, struct rsnd_dai_stream *io)
*/
u32 rsnd_get_dalign(struct rsnd_mod *mod, struct rsnd_dai_stream *io)
{
--- -- struct rsnd_mod *src = rsnd_io_to_mod_src(io);
struct rsnd_mod *ssi = rsnd_io_to_mod_ssi(io);
--- -- struct rsnd_mod *target = src ? src : ssi;
+++ ++ struct rsnd_mod *target;
struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
u32 val = 0x76543210;
u32 mask = ~0;
+++ ++ if (rsnd_io_is_play(io)) {
+++ ++ struct rsnd_mod *src = rsnd_io_to_mod_src(io);
+++ ++
+++ ++ target = src ? src : ssi;
+++ ++ } else {
+++ ++ struct rsnd_mod *cmd = rsnd_io_to_mod_cmd(io);
+++ ++
+++ ++ target = cmd ? cmd : ssi;
+++ ++ }
+++ ++
mask <<= runtime->channels * 4;
val = val & mask;
/*
* rsnd_dai functions
*/
-- --#define rsnd_mod_call(mod, io, func, param...) \
- #define __rsnd_mod_call(mod, io, func, param...) \
+++ ++#define rsnd_mod_call(idx, io, func, param...) \
({ \
struct rsnd_priv *priv = rsnd_mod_to_priv(mod); \
+++ ++ struct rsnd_mod *mod = (io)->mod[idx]; \
struct device *dev = rsnd_priv_to_dev(priv); \
+++ ++ u32 *status = (io)->mod_status + idx; \
u32 mask = 0xF << __rsnd_mod_shift_##func; \
--- -- u8 val = (mod->status >> __rsnd_mod_shift_##func) & 0xF; \
+++ ++ u8 val = (*status >> __rsnd_mod_shift_##func) & 0xF; \
u8 add = ((val + __rsnd_mod_add_##func) & 0xF); \
int ret = 0; \
- int called = 0; \
- if (val == __rsnd_mod_call_##func) { \
- called = 1; \
- ret = (mod)->ops->func(mod, io, param); \
- } \
- mod->status = (mod->status & ~mask) + \
+ int call = (val == __rsnd_mod_call_##func) && (mod)->ops->func; \
-- -- mod->status = (mod->status & ~mask) + \
+++ ++ *status = (*status & ~mask) + \
(add << __rsnd_mod_shift_##func); \
- dev_dbg(dev, "%s[%d] 0x%08x %s\n", \
- rsnd_mod_name(mod), rsnd_mod_id(mod), mod->status, \
- called ? #func : ""); \
+ dev_dbg(dev, "%s[%d]\t0x%08x %s\n", \
+ rsnd_mod_name(mod), rsnd_mod_id(mod), \
-- -- mod->status, call ? #func : ""); \
+++ ++ *status, call ? #func : ""); \
+ if (call) \
+ ret = (mod)->ops->func(mod, io, param); \
ret; \
})
- #define rsnd_mod_call(mod, io, func, param...) \
- (!(mod) ? -ENODEV : \
- !((mod)->ops->func) ? 0 : \
- __rsnd_mod_call(mod, io, func, param))
-
#define rsnd_dai_call(fn, io, param...) \
({ \
struct rsnd_mod *mod; \
mod = (io)->mod[i]; \
if (!mod) \
continue; \
-- -- ret |= rsnd_mod_call(mod, io, fn, param); \
- ret = rsnd_mod_call(mod, io, fn, param); \
- if (ret < 0) \
- break; \
+++ ++ ret |= rsnd_mod_call(i, io, fn, param); \
} \
ret; \
})
--- --static int rsnd_dai_connect(struct rsnd_mod *mod,
--- -- struct rsnd_dai_stream *io)
+++ ++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])
+++ ++ return -EINVAL;
+++ ++
priv = rsnd_mod_to_priv(mod);
dev = rsnd_priv_to_dev(priv);
--- -- io->mod[mod->type] = mod;
+++ ++ io->mod[type] = mod;
dev_dbg(dev, "%s[%d] is connected to io (%s)\n",
rsnd_mod_name(mod), rsnd_mod_id(mod),
}
static void rsnd_dai_disconnect(struct rsnd_mod *mod,
--- -- struct rsnd_dai_stream *io)
+++ ++ struct rsnd_dai_stream *io,
+++ ++ enum rsnd_mod_type type)
{
--- -- io->mod[mod->type] = NULL;
+++ ++ io->mod[type] = NULL;
}
struct rsnd_dai *rsnd_rdai_get(struct rsnd_priv *priv, int id)
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 ssi_id = rsnd_mod_id(rsnd_io_to_mod_ssi(io));
int ret;
unsigned long flags;
case SNDRV_PCM_TRIGGER_START:
rsnd_dai_stream_init(io, substream);
--- -- ret = rsnd_platform_call(priv, dai, start, ssi_id);
--- -- if (ret < 0)
--- -- goto dai_trigger_end;
--- --
ret = rsnd_dai_call(init, io, priv);
if (ret < 0)
goto dai_trigger_end;
break;
case SNDRV_PCM_TRIGGER_STOP:
ret = rsnd_dai_call(stop, io, priv);
- if (ret < 0)
- goto dai_trigger_end;
-
- ret = rsnd_dai_call(quit, io, priv);
- if (ret < 0)
- goto dai_trigger_end;
- ret = rsnd_platform_call(priv, dai, stop, ssi_id);
- if (ret < 0)
- goto dai_trigger_end;
+ ret |= rsnd_dai_call(quit, io, priv);
-- -- ret |= rsnd_platform_call(priv, dai, stop, ssi_id);
-- --
rsnd_dai_stream_quit(io);
break;
default:
return 0;
}
--- --static const struct snd_soc_dai_ops rsnd_soc_dai_ops = {
--- -- .trigger = rsnd_soc_dai_trigger,
--- -- .set_fmt = rsnd_soc_dai_set_fmt,
--- --};
--- --
--- --#define rsnd_path_add(priv, io, type) \
--- --({ \
--- -- struct rsnd_mod *mod; \
--- -- int ret = 0; \
--- -- int id = -1; \
--- -- \
--- -- if (rsnd_is_enable_path(io, type)) { \
--- -- id = rsnd_info_id(priv, io, type); \
--- -- if (id >= 0) { \
--- -- mod = rsnd_##type##_mod_get(priv, id); \
--- -- ret = rsnd_dai_connect(mod, io); \
--- -- } \
--- -- } \
--- -- ret; \
--- --})
--- --
--- --#define rsnd_path_remove(priv, io, type) \
--- --{ \
--- -- struct rsnd_mod *mod; \
--- -- int id = -1; \
--- -- \
--- -- if (rsnd_is_enable_path(io, type)) { \
--- -- id = rsnd_info_id(priv, io, type); \
--- -- if (id >= 0) { \
--- -- mod = rsnd_##type##_mod_get(priv, id); \
--- -- rsnd_dai_disconnect(mod, io); \
--- -- } \
--- -- } \
--- --}
--- --
--- --void rsnd_path_parse(struct rsnd_priv *priv,
--- -- struct rsnd_dai_stream *io)
+++ ++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_mod *dvc = rsnd_io_to_mod_dvc(io);
--- -- struct rsnd_mod *mix = rsnd_io_to_mod_mix(io);
--- -- struct rsnd_mod *src = rsnd_io_to_mod_src(io);
--- -- struct rsnd_mod *cmd;
+++ ++ 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);
--- -- u32 data;
-
- /* Gen1 is not supported */
- if (rsnd_is_gen1(priv))
- return;
-
- if (!mix && !dvc)
- return;
-
- if (mix) {
- struct rsnd_dai *rdai;
- int i;
- u32 path[] = {
- [0] = 0,
- [1] = 1 << 0,
- [2] = 0,
- [3] = 0,
- [4] = 0,
- [5] = 1 << 8
- };
-
- /*
- * it is assuming that integrater is well understanding about
- * data path. Here doesn't check impossible connection,
- * like src2 + src5
- */
- data = 0;
- for_each_rsnd_dai(rdai, priv, i) {
- io = &rdai->playback;
- if (mix == rsnd_io_to_mod_mix(io))
- data |= path[rsnd_mod_id(src)];
-
- io = &rdai->capture;
- if (mix == rsnd_io_to_mod_mix(io))
- data |= path[rsnd_mod_id(src)];
- }
-- -- /* Gen1 is not supported */
-- -- if (rsnd_is_gen1(priv))
-- -- return;
-- --
-- -- if (!mix && !dvc)
-- -- return;
-- --
-- -- if (mix) {
-- -- struct rsnd_dai *rdai;
-- -- int i;
-- -- u32 path[] = {
-- -- [0] = 0,
-- -- [1] = 1 << 0,
-- -- [2] = 0,
-- -- [3] = 0,
-- -- [4] = 0,
-- -- [5] = 1 << 8
-- -- };
-- --
-- -- /*
-- -- * it is assuming that integrater is well understanding about
-- -- * data path. Here doesn't check impossible connection,
-- -- * like src2 + src5
-- -- */
-- -- data = 0;
-- -- for_each_rsnd_dai(rdai, priv, i) {
-- -- io = &rdai->playback;
-- -- if (mix == rsnd_io_to_mod_mix(io))
-- -- data |= path[rsnd_mod_id(src)];
-- --
-- -- io = &rdai->capture;
-- -- if (mix == rsnd_io_to_mod_mix(io))
-- -- data |= path[rsnd_mod_id(src)];
-- -- }
-- --
--- -- /*
--- -- * We can't use ctu = rsnd_io_ctu() here.
--- -- * Since, ID of dvc/mix are 0 or 1 (= same as CMD number)
--- -- * but ctu IDs are 0 - 7 (= CTU00 - CTU13)
--- -- */
--- -- cmd = mix;
--- -- } else {
--- -- u32 path[] = {
--- -- [0] = 0x30000,
--- -- [1] = 0x30001,
--- -- [2] = 0x40000,
--- -- [3] = 0x10000,
--- -- [4] = 0x20000,
--- -- [5] = 0x40100
--- -- };
--- --
--- -- data = path[rsnd_mod_id(src)];
--- --
--- -- cmd = dvc;
+++ ++ switch (slots) {
+++ ++ case 6:
+++ ++ /* TDM Extend Mode */
+++ ++ rsnd_set_slot(rdai, slots, 1);
+++ ++ break;
+++ ++ default:
+++ ++ dev_err(dev, "unsupported TDM slots (%d)\n", slots);
+++ ++ return -EINVAL;
}
--- -- dev_dbg(dev, "ctu/mix path = 0x%08x", data);
--- --
--- -- rsnd_mod_write(cmd, CMD_ROUTE_SLCT, data);
--- --
--- -- rsnd_mod_write(cmd, CMD_CTRL, 0x10);
+++ ++ return 0;
}
--- --static int rsnd_path_init(struct rsnd_priv *priv,
--- -- struct rsnd_dai *rdai,
--- -- struct rsnd_dai_stream *io)
--- --{
--- -- int ret;
--- --
--- -- /*
--- -- * Gen1 is created by SRU/SSI, and this SRU is base module of
--- -- * Gen2's SCU/SSIU/SSI. (Gen2 SCU/SSIU came from SRU)
--- -- *
--- -- * Easy image is..
--- -- * Gen1 SRU = Gen2 SCU + SSIU + etc
--- -- *
--- -- * Gen2 SCU path is very flexible, but, Gen1 SRU (SCU parts) is
--- -- * using fixed path.
--- -- */
--- --
--- -- /* SSI */
--- -- ret = rsnd_path_add(priv, io, ssi);
--- -- if (ret < 0)
--- -- return ret;
--- --
--- -- /* SRC */
--- -- ret = rsnd_path_add(priv, io, src);
--- -- if (ret < 0)
--- -- return ret;
+++ ++static const struct snd_soc_dai_ops rsnd_soc_dai_ops = {
+++ ++ .trigger = rsnd_soc_dai_trigger,
+++ ++ .set_fmt = rsnd_soc_dai_set_fmt,
+++ ++ .set_tdm_slot = rsnd_soc_set_dai_tdm_slot,
+++ ++};
--- -- /* CTU */
--- -- ret = rsnd_path_add(priv, io, ctu);
--- -- if (ret < 0)
--- -- return ret;
+++ ++void rsnd_parse_connect_common(struct rsnd_dai *rdai,
+++ ++ 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_node *np;
+++ ++ struct rsnd_mod *mod;
+++ ++ int i;
--- -- /* MIX */
--- -- ret = rsnd_path_add(priv, io, mix);
--- -- if (ret < 0)
--- -- return ret;
+++ ++ if (!node)
+++ ++ return;
--- -- /* DVC */
--- -- ret = rsnd_path_add(priv, io, dvc);
--- -- if (ret < 0)
--- -- return ret;
+++ ++ i = 0;
+++ ++ for_each_child_of_node(node, np) {
+++ ++ 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++;
+++ ++ }
--- -- return ret;
+++ ++ of_node_put(node);
}
--- --static void rsnd_of_parse_dai(struct platform_device *pdev,
--- -- const struct rsnd_of_data *of_data,
--- -- struct rsnd_priv *priv)
+++ ++static int rsnd_dai_probe(struct rsnd_priv *priv)
{
--- -- struct device_node *dai_node, *dai_np;
--- -- struct device_node *ssi_node, *ssi_np;
--- -- struct device_node *src_node, *src_np;
--- -- struct device_node *ctu_node, *ctu_np;
--- -- struct device_node *mix_node, *mix_np;
--- -- struct device_node *dvc_node, *dvc_np;
+++ ++ struct device_node *dai_node;
+++ ++ struct device_node *dai_np;
struct device_node *playback, *capture;
--- -- struct rsnd_dai_platform_info *dai_info;
--- -- struct rcar_snd_info *info = rsnd_priv_to_info(priv);
--- -- struct device *dev = &pdev->dev;
--- -- int nr, i;
--- -- int dai_i, ssi_i, src_i, ctu_i, mix_i, dvc_i;
--- --
--- -- if (!of_data)
--- -- return;
--- --
--- -- dai_node = of_get_child_by_name(dev->of_node, "rcar_sound,dai");
--- -- if (!dai_node)
--- -- return;
+++ ++ struct rsnd_dai_stream *io_playback;
+++ ++ struct rsnd_dai_stream *io_capture;
+++ ++ struct snd_soc_dai_driver *rdrv, *drv;
+++ ++ struct rsnd_dai *rdai;
+++ ++ struct device *dev = rsnd_priv_to_dev(priv);
+++ ++ int nr, dai_i, io_i;
+++ ++ int ret;
+++ ++ dai_node = rsnd_dai_of_node(priv);
nr = of_get_child_count(dai_node);
--- -- if (!nr)
--- -- return;
+++ ++ if (!nr) {
+++ ++ ret = -EINVAL;
+++ ++ goto rsnd_dai_probe_done;
+++ ++ }
--- -- dai_info = devm_kzalloc(dev,
--- -- sizeof(struct rsnd_dai_platform_info) * nr,
--- -- GFP_KERNEL);
--- -- if (!dai_info) {
--- -- dev_err(dev, "dai info allocation error\n");
--- -- return;
+++ ++ rdrv = devm_kzalloc(dev, sizeof(*rdrv) * nr, GFP_KERNEL);
+++ ++ rdai = devm_kzalloc(dev, sizeof(*rdai) * nr, GFP_KERNEL);
+++ ++ if (!rdrv || !rdai) {
+++ ++ ret = -ENOMEM;
+++ ++ goto rsnd_dai_probe_done;
}
--- -- info->dai_info_nr = nr;
--- -- info->dai_info = dai_info;
--- --
--- -- ssi_node = of_get_child_by_name(dev->of_node, "rcar_sound,ssi");
--- -- src_node = of_get_child_by_name(dev->of_node, "rcar_sound,src");
--- -- ctu_node = of_get_child_by_name(dev->of_node, "rcar_sound,ctu");
--- -- mix_node = of_get_child_by_name(dev->of_node, "rcar_sound,mix");
--- -- dvc_node = of_get_child_by_name(dev->of_node, "rcar_sound,dvc");
--- --
--- --#define mod_parse(name) \
--- --if (name##_node) { \
--- -- struct rsnd_##name##_platform_info *name##_info; \
--- -- \
--- -- name##_i = 0; \
--- -- for_each_child_of_node(name##_node, name##_np) { \
--- -- name##_info = info->name##_info + name##_i; \
--- -- \
--- -- if (name##_np == playback) \
--- -- dai_info->playback.name = name##_info; \
--- -- if (name##_np == capture) \
--- -- dai_info->capture.name = name##_info; \
--- -- \
--- -- name##_i++; \
--- -- } \
--- --}
+++ ++ priv->rdai_nr = nr;
+++ ++ priv->daidrv = rdrv;
+++ ++ priv->rdai = rdai;
/*
* parse all dai
*/
dai_i = 0;
for_each_child_of_node(dai_node, dai_np) {
--- -- dai_info = info->dai_info + dai_i;
--- --
--- -- for (i = 0;; i++) {
--- --
--- -- playback = of_parse_phandle(dai_np, "playback", i);
--- -- capture = of_parse_phandle(dai_np, "capture", i);
+++ ++ rdai = rsnd_rdai_get(priv, dai_i);
+++ ++ drv = rdrv + 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;
+++ ++
+++ ++ snprintf(rdai->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 = 6;
+++ ++ drv->playback.stream_name = rdai->playback.name;
+++ ++
+++ ++ snprintf(rdai->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 = 6;
+++ ++ drv->capture.stream_name = rdai->capture.name;
+++ ++
+++ ++ rdai->playback.rdai = rdai;
+++ ++ rdai->capture.rdai = rdai;
+++ ++ rsnd_set_slot(rdai, 2, 1); /* default */
+++ ++
+++ ++ for (io_i = 0;; io_i++) {
+++ ++ playback = of_parse_phandle(dai_np, "playback", io_i);
+++ ++ capture = of_parse_phandle(dai_np, "capture", io_i);
if (!playback && !capture)
break;
--- -- mod_parse(ssi);
--- -- mod_parse(src);
--- -- mod_parse(ctu);
--- -- mod_parse(mix);
--- -- mod_parse(dvc);
+++ ++ rsnd_parse_connect_ssi(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);
}
dai_i++;
--- -- }
--- --}
--- --
--- --static int rsnd_dai_probe(struct platform_device *pdev,
--- -- const struct rsnd_of_data *of_data,
--- -- struct rsnd_priv *priv)
--- --{
--- -- struct snd_soc_dai_driver *drv;
--- -- struct rcar_snd_info *info = rsnd_priv_to_info(priv);
--- -- struct rsnd_dai *rdai;
--- -- struct rsnd_ssi_platform_info *pmod, *cmod;
--- -- struct device *dev = rsnd_priv_to_dev(priv);
--- -- int dai_nr;
--- -- int i;
-- --
-- -- rsnd_of_parse_dai(pdev, of_data, priv);
- rsnd_of_parse_dai(pdev, of_data, priv);
-
--- -- dai_nr = info->dai_info_nr;
--- -- if (!dai_nr) {
--- -- dev_err(dev, "no dai\n");
--- -- return -EIO;
+++ ++ 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" : " -- ");
}
--- -- drv = devm_kzalloc(dev, sizeof(*drv) * dai_nr, GFP_KERNEL);
--- -- rdai = devm_kzalloc(dev, sizeof(*rdai) * dai_nr, GFP_KERNEL);
--- -- if (!drv || !rdai) {
--- -- dev_err(dev, "dai allocate failed\n");
--- -- return -ENOMEM;
--- -- }
--- --
--- -- priv->rdai_nr = dai_nr;
--- -- priv->daidrv = drv;
--- -- priv->rdai = rdai;
+++ ++ ret = 0;
--- -- for (i = 0; i < dai_nr; i++) {
+++ ++rsnd_dai_probe_done:
+++ ++ of_node_put(dai_node);
--- -- pmod = info->dai_info[i].playback.ssi;
--- -- cmod = info->dai_info[i].capture.ssi;
--- --
--- -- /*
--- -- * init rsnd_dai
--- -- */
--- -- snprintf(rdai[i].name, RSND_DAI_NAME_SIZE, "rsnd-dai.%d", i);
--- -- rdai[i].priv = priv;
--- --
--- -- /*
--- -- * init snd_soc_dai_driver
--- -- */
--- -- drv[i].name = rdai[i].name;
--- -- drv[i].ops = &rsnd_soc_dai_ops;
--- -- if (pmod) {
--- -- snprintf(rdai[i].playback.name, RSND_DAI_NAME_SIZE,
--- -- "DAI%d Playback", i);
--- --
--- -- drv[i].playback.rates = RSND_RATES;
--- -- drv[i].playback.formats = RSND_FMTS;
--- -- drv[i].playback.channels_min = 2;
--- -- drv[i].playback.channels_max = 2;
--- -- drv[i].playback.stream_name = rdai[i].playback.name;
--- --
--- -- rdai[i].playback.info = &info->dai_info[i].playback;
--- -- rdai[i].playback.rdai = rdai + i;
--- -- rsnd_path_init(priv, &rdai[i], &rdai[i].playback);
--- -- }
--- -- if (cmod) {
--- -- snprintf(rdai[i].capture.name, RSND_DAI_NAME_SIZE,
--- -- "DAI%d Capture", i);
--- --
--- -- drv[i].capture.rates = RSND_RATES;
--- -- drv[i].capture.formats = RSND_FMTS;
--- -- drv[i].capture.channels_min = 2;
--- -- drv[i].capture.channels_max = 2;
--- -- drv[i].capture.stream_name = rdai[i].capture.name;
--- --
--- -- rdai[i].capture.info = &info->dai_info[i].capture;
--- -- rdai[i].capture.rdai = rdai + i;
--- -- rsnd_path_init(priv, &rdai[i], &rdai[i].capture);
--- -- }
--- --
--- -- dev_dbg(dev, "%s (%s/%s)\n", rdai[i].name,
--- -- pmod ? "play" : " -- ",
--- -- cmod ? "capture" : " -- ");
--- -- }
--- --
--- -- return 0;
+++ ++ return ret;
}
/*
void (*update)(struct rsnd_dai_stream *io,
struct rsnd_mod *mod))
{
----- struct snd_soc_card *soc_card = rtd->card;
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 - soc_card->rtd,
+++++ .index = rtd->num,
.get = rsnd_kctrl_get,
.put = rsnd_kctrl_put,
.private_value = (unsigned long)cfg,
void (*update)(struct rsnd_dai_stream *io,
struct rsnd_mod *mod),
struct rsnd_kctrl_cfg_m *_cfg,
+++ ++ int ch_size,
u32 max)
{
+++ ++ if (ch_size > RSND_DVC_CHANNELS)
+++ ++ return -EINVAL;
+++ ++
_cfg->cfg.max = max;
--- -- _cfg->cfg.size = RSND_DVC_CHANNELS;
+++ ++ _cfg->cfg.size = ch_size;
_cfg->cfg.val = _cfg->val;
return __rsnd_kctrl_new(mod, io, rtd, name, &_cfg->cfg, update);
}
ret = rsnd_dai_call(probe, io, priv);
if (ret == -EAGAIN) {
+++ ++ struct rsnd_mod *ssi_mod = rsnd_io_to_mod_ssi(io);
+++ ++ int i;
+++ ++
/*
* Fallback to PIO mode
*/
rsnd_dai_call(remove, io, priv);
/*
--- -- * remove SRC/DVC from DAI,
+++ ++ * remove all mod from io
+++ ++ * and, re connect ssi
*/
--- -- rsnd_path_remove(priv, io, src);
--- -- rsnd_path_remove(priv, io, dvc);
+++ ++ for (i = 0; i < RSND_MOD_MAX; i++)
+++ ++ rsnd_dai_disconnect((io)->mod[i], io, i);
+++ ++ rsnd_dai_connect(ssi_mod, io, RSND_MOD_SSI);
/*
* fallback
*/
static int rsnd_probe(struct platform_device *pdev)
{
--- -- struct rcar_snd_info *info;
struct rsnd_priv *priv;
struct device *dev = &pdev->dev;
struct rsnd_dai *rdai;
const struct of_device_id *of_id = of_match_device(rsnd_of_match, dev);
--- -- const struct rsnd_of_data *of_data;
--- -- int (*probe_func[])(struct platform_device *pdev,
--- -- const struct rsnd_of_data *of_data,
--- -- struct rsnd_priv *priv) = {
+++ ++ 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;
-- -- info = devm_kzalloc(&pdev->dev, sizeof(struct rcar_snd_info),
-- -- GFP_KERNEL);
-- -- if (!info)
-- -- return -ENOMEM;
-- -- of_data = of_id->data;
- info = NULL;
- of_data = NULL;
- if (of_id) {
- info = devm_kzalloc(&pdev->dev,
- sizeof(struct rcar_snd_info), GFP_KERNEL);
- of_data = of_id->data;
- } else {
- info = pdev->dev.platform_data;
- }
-
- if (!info) {
- dev_err(dev, "driver needs R-Car sound information\n");
- return -ENODEV;
- }
--- --
/*
* init priv data
*/
}
priv->pdev = pdev;
--- -- priv->info = info;
+++ ++ priv->flags = (unsigned long)of_id->data;
spin_lock_init(&priv->lock);
/*
* init each module
*/
for (i = 0; i < ARRAY_SIZE(probe_func); i++) {
--- -- ret = probe_func[i](pdev, of_data, priv);
+++ ++ ret = probe_func[i](priv);
if (ret)
return ret;
}
{
struct rsnd_priv *priv = dev_get_drvdata(&pdev->dev);
struct rsnd_dai *rdai;
--- -- void (*remove_func[])(struct platform_device *pdev,
--- -- struct rsnd_priv *priv) = {
+++ ++ 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 ret = 0, i;
}
for (i = 0; i < ARRAY_SIZE(remove_func); i++)
--- -- remove_func[i](pdev, priv);
+++ ++ remove_func[i](priv);
snd_soc_unregister_component(&pdev->dev);
snd_soc_unregister_platform(&pdev->dev);
#include "rsnd.h"
struct rsnd_gen {
- void __iomem *base[RSND_BASE_MAX];
-
struct rsnd_gen_ops *ops;
+ /* RSND_BASE_MAX base */
+ void __iomem *base[RSND_BASE_MAX];
+ phys_addr_t res[RSND_BASE_MAX];
struct regmap *regmap[RSND_BASE_MAX];
+
+ /* RSND_REG_MAX base */
struct regmap_field *regs[RSND_REG_MAX];
- phys_addr_t res[RSND_REG_MAX];
+++ ++ const char *reg_name[RSND_REG_MAX];
};
#define rsnd_priv_to_gen(p) ((struct rsnd_gen *)(p)->gen)
+++ ++#define rsnd_reg_name(gen, id) ((gen)->reg_name[id])
struct rsnd_regmap_field_conf {
int idx;
unsigned int reg_offset;
unsigned int id_offset;
+++ ++ const char *reg_name;
};
--- --#define RSND_REG_SET(id, offset, _id_offset) \
+++ ++#define RSND_REG_SET(id, offset, _id_offset, n) \
{ \
.idx = id, \
.reg_offset = offset, \
.id_offset = _id_offset, \
+++ ++ .reg_name = n, \
}
/* single address mapping */
#define RSND_GEN_S_REG(id, offset) \
--- -- RSND_REG_SET(RSND_REG_##id, offset, 0)
+++ ++ RSND_REG_SET(RSND_REG_##id, offset, 0, #id)
/* multi address mapping */
#define RSND_GEN_M_REG(id, offset, _id_offset) \
--- -- RSND_REG_SET(RSND_REG_##id, offset, _id_offset)
+++ ++ RSND_REG_SET(RSND_REG_##id, offset, _id_offset, #id)
/*
* basic function
if (!rsnd_is_accessible_reg(priv, gen, reg))
return 0;
- dev_dbg(dev, "r %s[%d] - %4d : %08x\n",
- rsnd_mod_name(mod), rsnd_mod_id(mod), reg, val);
-
regmap_fields_read(gen->regs[reg], rsnd_mod_id(mod), &val);
-- -- dev_dbg(dev, "r %s[%d] - %4d : %08x\n",
-- -- rsnd_mod_name(mod), rsnd_mod_id(mod), reg, val);
+++ ++ dev_dbg(dev, "r %s[%d] - %-18s (%4d) : %08x\n",
+++ ++ rsnd_mod_name(mod), rsnd_mod_id(mod),
+++ ++ rsnd_reg_name(gen, reg), reg, val);
+
return val;
}
if (!rsnd_is_accessible_reg(priv, gen, reg))
return;
--- -- dev_dbg(dev, "w %s[%d] - %4d : %08x\n",
--- -- rsnd_mod_name(mod), rsnd_mod_id(mod), reg, data);
--- --
regmap_fields_write(gen->regs[reg], rsnd_mod_id(mod), data);
+++ ++
+++ ++ dev_dbg(dev, "w %s[%d] - %-18s (%4d) : %08x\n",
+++ ++ rsnd_mod_name(mod), rsnd_mod_id(mod),
+++ ++ rsnd_reg_name(gen, reg), reg, data);
}
void rsnd_force_write(struct rsnd_priv *priv,
if (!rsnd_is_accessible_reg(priv, gen, reg))
return;
--- -- dev_dbg(dev, "w %s[%d] - %4d : %08x\n",
--- -- rsnd_mod_name(mod), rsnd_mod_id(mod), reg, data);
--- --
regmap_fields_force_write(gen->regs[reg], rsnd_mod_id(mod), data);
+++ ++
+++ ++ dev_dbg(dev, "w %s[%d] - %-18s (%4d) : %08x\n",
+++ ++ rsnd_mod_name(mod), rsnd_mod_id(mod),
+++ ++ rsnd_reg_name(gen, reg), reg, data);
}
void rsnd_bset(struct rsnd_priv *priv, struct rsnd_mod *mod,
if (!rsnd_is_accessible_reg(priv, gen, reg))
return;
--- -- dev_dbg(dev, "b %s[%d] - %4d : %08x/%08x\n",
--- -- rsnd_mod_name(mod), rsnd_mod_id(mod), reg, data, mask);
--- --
regmap_fields_update_bits(gen->regs[reg], rsnd_mod_id(mod),
mask, data);
+++ ++
+++ ++ dev_dbg(dev, "b %s[%d] - %-18s (%4d) : %08x/%08x\n",
+++ ++ rsnd_mod_name(mod), rsnd_mod_id(mod),
+++ ++ rsnd_reg_name(gen, reg), reg, data, mask);
+++ ++
}
phys_addr_t rsnd_gen_get_phy_addr(struct rsnd_priv *priv, int reg_id)
int id_size,
int reg_id,
const char *name,
--- -- struct rsnd_regmap_field_conf *conf,
+++ ++ const struct rsnd_regmap_field_conf *conf,
int conf_size)
{
struct platform_device *pdev = rsnd_priv_to_pdev(priv);
if (IS_ERR(regmap))
return PTR_ERR(regmap);
+ /* RSND_BASE_MAX base */
gen->base[reg_id] = base;
gen->regmap[reg_id] = regmap;
gen->res[reg_id] = res->start;
if (IS_ERR(regs))
return PTR_ERR(regs);
+ /* RSND_REG_MAX base */
gen->regs[conf[i].idx] = regs;
+++ ++ gen->reg_name[conf[i].idx] = conf[i].reg_name;
}
return 0;
/*
* Gen2
*/
--- --static int rsnd_gen2_probe(struct platform_device *pdev,
--- -- struct rsnd_priv *priv)
+++ ++static int rsnd_gen2_probe(struct rsnd_priv *priv)
{
--- -- struct rsnd_regmap_field_conf conf_ssiu[] = {
+++ ++ const static struct rsnd_regmap_field_conf conf_ssiu[] = {
RSND_GEN_S_REG(SSI_MODE0, 0x800),
RSND_GEN_S_REG(SSI_MODE1, 0x804),
+++ ++ RSND_GEN_S_REG(SSI_MODE2, 0x808),
+++ ++ RSND_GEN_S_REG(SSI_CONTROL, 0x810),
+++ ++
/* FIXME: it needs SSI_MODE2/3 in the future */
RSND_GEN_M_REG(SSI_BUSIF_MODE, 0x0, 0x80),
RSND_GEN_M_REG(SSI_BUSIF_ADINR, 0x4, 0x80),
RSND_GEN_M_REG(SSI_BUSIF_DALIGN,0x8, 0x80),
+++ ++ RSND_GEN_M_REG(SSI_MODE, 0xc, 0x80),
RSND_GEN_M_REG(SSI_CTRL, 0x10, 0x80),
RSND_GEN_M_REG(SSI_INT_ENABLE, 0x18, 0x80),
};
--- -- struct rsnd_regmap_field_conf conf_scu[] = {
--- -- RSND_GEN_M_REG(SRC_BUSIF_MODE, 0x0, 0x20),
+++ ++
+++ ++ const static struct rsnd_regmap_field_conf conf_scu[] = {
+++ ++ RSND_GEN_M_REG(SRC_I_BUSIF_MODE,0x0, 0x20),
+++ ++ RSND_GEN_M_REG(SRC_O_BUSIF_MODE,0x4, 0x20),
RSND_GEN_M_REG(SRC_BUSIF_DALIGN,0x8, 0x20),
RSND_GEN_M_REG(SRC_ROUTE_MODE0, 0xc, 0x20),
RSND_GEN_M_REG(SRC_CTRL, 0x10, 0x20),
RSND_GEN_M_REG(SRC_INT_ENABLE0, 0x18, 0x20),
+++ ++ RSND_GEN_M_REG(CMD_BUSIF_DALIGN,0x188, 0x20),
RSND_GEN_M_REG(CMD_ROUTE_SLCT, 0x18c, 0x20),
RSND_GEN_M_REG(CMD_CTRL, 0x190, 0x20),
RSND_GEN_S_REG(SCU_SYS_STATUS0, 0x1c8),
RSND_GEN_S_REG(SCU_SYS_INT_EN0, 0x1cc),
RSND_GEN_S_REG(SCU_SYS_STATUS1, 0x1d0),
----- RSND_GEN_S_REG(SCU_SYS_INT_EN1, 0x1c4),
+++++ RSND_GEN_S_REG(SCU_SYS_INT_EN1, 0x1d4),
RSND_GEN_M_REG(SRC_SWRSR, 0x200, 0x40),
RSND_GEN_M_REG(SRC_SRCIR, 0x204, 0x40),
RSND_GEN_M_REG(SRC_ADINR, 0x214, 0x40),
RSND_GEN_M_REG(DVC_VRDBR, 0xe20, 0x100),
RSND_GEN_M_REG(DVC_VOL0R, 0xe28, 0x100),
RSND_GEN_M_REG(DVC_VOL1R, 0xe2c, 0x100),
+++ ++ RSND_GEN_M_REG(DVC_VOL2R, 0xe30, 0x100),
+++ ++ RSND_GEN_M_REG(DVC_VOL3R, 0xe34, 0x100),
+++ ++ RSND_GEN_M_REG(DVC_VOL4R, 0xe38, 0x100),
+++ ++ RSND_GEN_M_REG(DVC_VOL5R, 0xe3c, 0x100),
+++ ++ RSND_GEN_M_REG(DVC_VOL6R, 0xe40, 0x100),
+++ ++ RSND_GEN_M_REG(DVC_VOL7R, 0xe44, 0x100),
RSND_GEN_M_REG(DVC_DVUER, 0xe48, 0x100),
};
--- -- struct rsnd_regmap_field_conf conf_adg[] = {
+++ ++ const static struct rsnd_regmap_field_conf conf_adg[] = {
RSND_GEN_S_REG(BRRA, 0x00),
RSND_GEN_S_REG(BRRB, 0x04),
RSND_GEN_S_REG(SSICKR, 0x08),
RSND_GEN_S_REG(SRCOUT_TIMSEL4, 0x58),
RSND_GEN_S_REG(CMDOUT_TIMSEL, 0x5c),
};
--- -- struct rsnd_regmap_field_conf conf_ssi[] = {
+++ ++ const static struct rsnd_regmap_field_conf conf_ssi[] = {
RSND_GEN_M_REG(SSICR, 0x00, 0x40),
RSND_GEN_M_REG(SSISR, 0x04, 0x40),
RSND_GEN_M_REG(SSITDR, 0x08, 0x40),
* Gen1
*/
--- --static int rsnd_gen1_probe(struct platform_device *pdev,
--- -- struct rsnd_priv *priv)
+++ ++static int rsnd_gen1_probe(struct rsnd_priv *priv)
{
--- -- struct rsnd_regmap_field_conf conf_sru[] = {
--- -- RSND_GEN_S_REG(SRC_ROUTE_SEL, 0x00),
--- -- RSND_GEN_S_REG(SRC_TMG_SEL0, 0x08),
--- -- RSND_GEN_S_REG(SRC_TMG_SEL1, 0x0c),
--- -- RSND_GEN_S_REG(SRC_TMG_SEL2, 0x10),
--- -- RSND_GEN_S_REG(SRC_ROUTE_CTRL, 0xc0),
--- -- RSND_GEN_S_REG(SSI_MODE0, 0xD0),
--- -- RSND_GEN_S_REG(SSI_MODE1, 0xD4),
--- -- RSND_GEN_M_REG(SRC_BUSIF_MODE, 0x20, 0x4),
--- -- RSND_GEN_M_REG(SRC_ROUTE_MODE0, 0x50, 0x8),
--- -- RSND_GEN_M_REG(SRC_SWRSR, 0x200, 0x40),
--- -- RSND_GEN_M_REG(SRC_SRCIR, 0x204, 0x40),
--- -- RSND_GEN_M_REG(SRC_ADINR, 0x214, 0x40),
--- -- RSND_GEN_M_REG(SRC_IFSCR, 0x21c, 0x40),
--- -- RSND_GEN_M_REG(SRC_IFSVR, 0x220, 0x40),
--- -- RSND_GEN_M_REG(SRC_SRCCR, 0x224, 0x40),
--- -- RSND_GEN_M_REG(SRC_MNFSR, 0x228, 0x40),
--- -- /*
--- -- * ADD US
--- -- *
--- -- * SRC_STATUS
--- -- * SRC_INT_EN
--- -- * SCU_SYS_STATUS0
--- -- * SCU_SYS_STATUS1
--- -- * SCU_SYS_INT_EN0
--- -- * SCU_SYS_INT_EN1
--- -- */
--- -- };
--- -- struct rsnd_regmap_field_conf conf_adg[] = {
+++ ++ const static struct rsnd_regmap_field_conf conf_adg[] = {
RSND_GEN_S_REG(BRRA, 0x00),
RSND_GEN_S_REG(BRRB, 0x04),
RSND_GEN_S_REG(SSICKR, 0x08),
RSND_GEN_S_REG(AUDIO_CLK_SEL0, 0x0c),
RSND_GEN_S_REG(AUDIO_CLK_SEL1, 0x10),
--- -- RSND_GEN_S_REG(AUDIO_CLK_SEL3, 0x18),
--- -- RSND_GEN_S_REG(AUDIO_CLK_SEL4, 0x1c),
--- -- RSND_GEN_S_REG(AUDIO_CLK_SEL5, 0x20),
};
--- -- struct rsnd_regmap_field_conf conf_ssi[] = {
+++ ++ const static struct rsnd_regmap_field_conf conf_ssi[] = {
RSND_GEN_M_REG(SSICR, 0x00, 0x40),
RSND_GEN_M_REG(SSISR, 0x04, 0x40),
RSND_GEN_M_REG(SSITDR, 0x08, 0x40),
RSND_GEN_M_REG(SSIRDR, 0x0c, 0x40),
RSND_GEN_M_REG(SSIWSR, 0x20, 0x40),
};
--- -- int ret_sru;
int ret_adg;
int ret_ssi;
--- -- ret_sru = rsnd_gen_regmap_init(priv, 9, RSND_GEN1_SRU, "sru", conf_sru);
ret_adg = rsnd_gen_regmap_init(priv, 9, RSND_GEN1_ADG, "adg", conf_adg);
ret_ssi = rsnd_gen_regmap_init(priv, 9, RSND_GEN1_SSI, "ssi", conf_ssi);
--- -- if (ret_sru < 0 ||
--- -- ret_adg < 0 ||
+++ ++ if (ret_adg < 0 ||
ret_ssi < 0)
--- -- return ret_sru | ret_adg | ret_ssi;
+++ ++ return ret_adg | ret_ssi;
return 0;
}
/*
* Gen
*/
--- --static void rsnd_of_parse_gen(struct platform_device *pdev,
--- -- const struct rsnd_of_data *of_data,
--- -- struct rsnd_priv *priv)
--- --{
--- -- struct rcar_snd_info *info = priv->info;
--- --
--- -- if (!of_data)
--- -- return;
--- --
--- -- info->flags = of_data->flags;
--- --}
--- --
--- --int rsnd_gen_probe(struct platform_device *pdev,
--- -- const struct rsnd_of_data *of_data,
--- -- struct rsnd_priv *priv)
+++ ++int rsnd_gen_probe(struct rsnd_priv *priv)
{
struct device *dev = rsnd_priv_to_dev(priv);
struct rsnd_gen *gen;
int ret;
--- -- rsnd_of_parse_gen(pdev, of_data, priv);
--- --
gen = devm_kzalloc(dev, sizeof(*gen), GFP_KERNEL);
if (!gen) {
dev_err(dev, "GEN allocate failed\n");
ret = -ENODEV;
if (rsnd_is_gen1(priv))
--- -- ret = rsnd_gen1_probe(pdev, priv);
+++ ++ ret = rsnd_gen1_probe(priv);
else if (rsnd_is_gen2(priv))
--- -- ret = rsnd_gen2_probe(pdev, priv);
+++ ++ ret = rsnd_gen2_probe(priv);
if (ret < 0)
dev_err(dev, "unknown generation R-Car sound device\n");
#define DAI_NAME_NUM 32
struct rsrc_card_dai {
--- -- unsigned int fmt;
unsigned int sysclk;
+++ ++ unsigned int tx_slot_mask;
+++ ++ unsigned int rx_slot_mask;
+++ ++ int slots;
+++ ++ int slot_width;
struct clk *clk;
char dai_name[DAI_NAME_NUM];
};
struct snd_soc_pcm_runtime *rtd = substream->private_data;
struct rsrc_card_priv *priv = snd_soc_card_get_drvdata(rtd->card);
struct rsrc_card_dai *dai_props =
----- rsrc_priv_to_props(priv, rtd - rtd->card->rtd);
+++++ rsrc_priv_to_props(priv, rtd->num);
return clk_prepare_enable(dai_props->clk);
}
struct snd_soc_pcm_runtime *rtd = substream->private_data;
struct rsrc_card_priv *priv = snd_soc_card_get_drvdata(rtd->card);
struct rsrc_card_dai *dai_props =
----- rsrc_priv_to_props(priv, rtd - rtd->card->rtd);
+++++ rsrc_priv_to_props(priv, rtd->num);
clk_disable_unprepare(dai_props->clk);
}
struct snd_soc_dai *dai;
struct snd_soc_dai_link *dai_link;
struct rsrc_card_dai *dai_props;
----- int num = rtd - rtd->card->rtd;
+++++ int num = rtd->num;
int ret;
dai_link = rsrc_priv_to_link(priv, num);
rtd->cpu_dai :
rtd->codec_dai;
--- -- if (dai_props->fmt) {
--- -- ret = snd_soc_dai_set_fmt(dai, dai_props->fmt);
+++ ++ if (dai_props->sysclk) {
+++ ++ ret = snd_soc_dai_set_sysclk(dai, 0, dai_props->sysclk, 0);
if (ret && ret != -ENOTSUPP) {
--- -- dev_err(dai->dev, "set_fmt error\n");
+++ ++ dev_err(dai->dev, "set_sysclk error\n");
goto err;
}
}
--- -- if (dai_props->sysclk) {
--- -- ret = snd_soc_dai_set_sysclk(dai, 0, dai_props->sysclk, 0);
+++ ++ if (dai_props->slots) {
+++ ++ ret = snd_soc_dai_set_tdm_slot(dai,
+++ ++ dai_props->tx_slot_mask,
+++ ++ dai_props->rx_slot_mask,
+++ ++ dai_props->slots,
+++ ++ dai_props->slot_width);
if (ret && ret != -ENOTSUPP) {
--- -- dev_err(dai->dev, "set_sysclk error\n");
+++ ++ dev_err(dai->dev, "set_tdm_slot error\n");
goto err;
}
}
}
static int rsrc_card_parse_daifmt(struct device_node *node,
--- -- struct device_node *np,
+++ ++ struct device_node *codec,
struct rsrc_card_priv *priv,
--- -- int idx, bool is_fe)
+++ ++ struct snd_soc_dai_link *dai_link,
+++ ++ unsigned int *retfmt)
{
--- -- struct rsrc_card_dai *dai_props = rsrc_priv_to_props(priv, idx);
struct device_node *bitclkmaster = NULL;
struct device_node *framemaster = NULL;
--- -- struct device_node *codec = is_fe ? NULL : np;
unsigned int daifmt;
daifmt = snd_soc_of_parse_daifmt(node, NULL,
daifmt |= (codec == framemaster) ?
SND_SOC_DAIFMT_CBS_CFM : SND_SOC_DAIFMT_CBS_CFS;
--- -- dai_props->fmt = daifmt;
--- --
of_node_put(bitclkmaster);
of_node_put(framemaster);
+++ ++ *retfmt = daifmt;
+++ ++
return 0;
}
if (ret)
return ret;
+++ ++ /* Parse TDM slot */
+++ ++ ret = snd_soc_of_parse_tdm_slot(np,
+++ ++ &dai_props->tx_slot_mask,
+++ ++ &dai_props->rx_slot_mask,
+++ ++ &dai_props->slots,
+++ ++ &dai_props->slot_width);
+++ ++ if (ret)
+++ ++ return ret;
+++ ++
if (is_fe) {
/* BE is dummy */
dai_link->codec_of_node = NULL;
dai_link->dynamic = 1;
dai_link->dpcm_merged_format = 1;
dai_link->cpu_of_node = args.np;
--- -- snd_soc_of_get_dai_name(np, &dai_link->cpu_dai_name);
+++ ++ ret = snd_soc_of_get_dai_name(np, &dai_link->cpu_dai_name);
+++ ++ if (ret < 0)
+++ ++ return ret;
/* set dai_name */
snprintf(dai_props->dai_name, DAI_NAME_NUM, "fe.%s",
dai_link->no_pcm = 1;
dai_link->be_hw_params_fixup = rsrc_card_be_hw_params_fixup;
dai_link->codec_of_node = args.np;
--- -- snd_soc_of_get_dai_name(np, &dai_link->codec_dai_name);
+++ ++ ret = snd_soc_of_get_dai_name(np, &dai_link->codec_dai_name);
+++ ++ if (ret < 0)
+++ ++ return ret;
/* additional name prefix */
if (of_data) {
return 0;
}
--- --static int rsrc_card_dai_link_of(struct device_node *node,
--- -- struct device_node *np,
--- -- struct rsrc_card_priv *priv,
--- -- int idx)
+++ ++static int rsrc_card_dai_sub_link_of(struct device_node *node,
+++ ++ struct device_node *np,
+++ ++ struct rsrc_card_priv *priv,
+++ ++ int idx, bool is_fe)
{
struct device *dev = rsrc_priv_to_dev(priv);
+++ ++ struct snd_soc_dai_link *dai_link = rsrc_priv_to_link(priv, idx);
struct rsrc_card_dai *dai_props = rsrc_priv_to_props(priv, idx);
--- -- bool is_fe = false;
int ret;
--- -- if (0 == strcmp(np->name, "cpu"))
--- -- is_fe = true;
--- --
--- -- ret = rsrc_card_parse_daifmt(node, np, priv, idx, is_fe);
--- -- if (ret < 0)
--- -- return ret;
--- --
ret = rsrc_card_parse_links(np, priv, idx, is_fe);
if (ret < 0)
return ret;
dev_dbg(dev, "\t%s / %04x / %d\n",
dai_props->dai_name,
--- -- dai_props->fmt,
+++ ++ dai_link->dai_fmt,
dai_props->sysclk);
return ret;
}
+++ ++static int rsrc_card_dai_link_of(struct device_node *node,
+++ ++ struct rsrc_card_priv *priv)
+++ ++{
+++ ++ struct snd_soc_dai_link *dai_link;
+++ ++ struct device_node *np;
+++ ++ unsigned int daifmt = 0;
+++ ++ int ret, i;
+++ ++ bool is_fe;
+++ ++
+++ ++ /* find 1st codec */
+++ ++ i = 0;
+++ ++ for_each_child_of_node(node, np) {
+++ ++ dai_link = rsrc_priv_to_link(priv, i);
+++ ++
+++ ++ if (strcmp(np->name, "codec") == 0) {
+++ ++ ret = rsrc_card_parse_daifmt(node, np, priv,
+++ ++ dai_link, &daifmt);
+++ ++ if (ret < 0)
+++ ++ return ret;
+++ ++ break;
+++ ++ }
+++ ++ i++;
+++ ++ }
+++ ++
+++ ++ i = 0;
+++ ++ for_each_child_of_node(node, np) {
+++ ++ dai_link = rsrc_priv_to_link(priv, i);
+++ ++ dai_link->dai_fmt = daifmt;
+++ ++
+++ ++ is_fe = false;
+++ ++ if (strcmp(np->name, "cpu") == 0)
+++ ++ is_fe = true;
+++ ++
+++ ++ ret = rsrc_card_dai_sub_link_of(node, np, priv, i, is_fe);
+++ ++ if (ret < 0)
+++ ++ return ret;
+++ ++ i++;
+++ ++ }
+++ ++
+++ ++ return 0;
+++ ++}
+++ ++
static int rsrc_card_parse_of(struct device_node *node,
struct rsrc_card_priv *priv,
struct device *dev)
const struct rsrc_card_of_data *of_data = rsrc_dev_to_of_data(dev);
struct rsrc_card_dai *props;
struct snd_soc_dai_link *links;
--- -- struct device_node *np;
int ret;
--- -- int i, num;
+++ ++ int num;
if (!node)
return -EINVAL;
priv->snd_card.name ? priv->snd_card.name : "",
priv->convert_rate);
--- -- i = 0;
--- -- for_each_child_of_node(node, np) {
--- -- ret = rsrc_card_dai_link_of(node, np, priv, i);
--- -- if (ret < 0)
--- -- return ret;
--- -- i++;
--- -- }
+++ ++ ret = rsrc_card_dai_link_of(node, priv);
+++ ++ if (ret < 0)
+++ ++ return ret;
if (!priv->snd_card.name)
priv->snd_card.name = priv->snd_card.dai_link->name;
#define OUF_SRC(id) ((1 << (id + 16)) | (1 << id))
struct rsnd_src {
--- -- struct rsnd_src_platform_info *info; /* rcar_snd.h */
struct rsnd_mod mod;
+++ ++ struct rsnd_mod *dma;
struct rsnd_kctrl_cfg_s sen; /* sync convert enable */
struct rsnd_kctrl_cfg_s sync; /* sync convert */
u32 convert_rate; /* sampling rate convert */
int err;
+++ ++ int irq;
};
#define RSND_SRC_NAME_SIZE 16
+++ ++#define rsnd_src_get(priv, id) ((struct rsnd_src *)(priv->src) + id)
+++ ++#define rsnd_src_to_dma(src) ((src)->dma)
#define rsnd_src_nr(priv) ((priv)->src_nr)
#define rsnd_enable_sync_convert(src) ((src)->sen.val)
--- --#define rsnd_src_of_node(priv) \
--- -- of_get_child_by_name(rsnd_priv_to_dev(priv)->of_node, "rcar_sound,src")
#define rsnd_mod_to_src(_mod) \
container_of((_mod), struct rsnd_src, mod)
* |-----------------|
*/
--- --/*
--- -- * How to use SRC bypass mode for debugging
--- -- *
--- -- * SRC has bypass mode, and it is useful for debugging.
--- -- * In Gen2 case,
--- -- * SRCm_MODE controls whether SRC is used or not
--- -- * SSI_MODE0 controls whether SSIU which receives SRC data
--- -- * is used or not.
--- -- * Both SRCm_MODE/SSI_MODE0 settings are needed if you use SRC,
--- -- * but SRC bypass mode needs SSI_MODE0 only.
--- -- *
--- -- * This driver request
--- -- * struct rsnd_src_platform_info {
--- -- * u32 convert_rate;
--- -- * int dma_id;
--- -- * }
--- -- *
--- -- * rsnd_src_convert_rate() indicates
--- -- * above convert_rate, and it controls
--- -- * whether SRC is used or not.
--- -- *
--- -- * ex) doesn't use SRC
--- -- * static struct rsnd_dai_platform_info rsnd_dai = {
--- -- * .playback = { .ssi = &rsnd_ssi[0], },
--- -- * };
--- -- *
--- -- * ex) uses SRC
--- -- * static struct rsnd_src_platform_info rsnd_src[] = {
--- -- * RSND_SCU(48000, 0),
--- -- * ...
--- -- * };
--- -- * static struct rsnd_dai_platform_info rsnd_dai = {
--- -- * .playback = { .ssi = &rsnd_ssi[0], .src = &rsnd_src[0] },
--- -- * };
--- -- *
--- -- * ex) uses SRC bypass mode
--- -- * static struct rsnd_src_platform_info rsnd_src[] = {
--- -- * RSND_SCU(0, 0),
--- -- * ...
--- -- * };
--- -- * static struct rsnd_dai_platform_info rsnd_dai = {
--- -- * .playback = { .ssi = &rsnd_ssi[0], .src = &rsnd_src[0] },
--- -- * };
--- -- *
--- -- */
--- --
--- --/*
--- -- * Gen1/Gen2 common functions
--- -- */
--- --static void rsnd_src_soft_reset(struct rsnd_mod *mod)
+++ ++static void rsnd_src_activation(struct rsnd_mod *mod)
{
rsnd_mod_write(mod, SRC_SWRSR, 0);
rsnd_mod_write(mod, SRC_SWRSR, 1);
}
--- --
--- --#define rsnd_src_initialize_lock(mod) __rsnd_src_initialize_lock(mod, 1)
--- --#define rsnd_src_initialize_unlock(mod) __rsnd_src_initialize_lock(mod, 0)
--- --static void __rsnd_src_initialize_lock(struct rsnd_mod *mod, u32 enable)
+++ ++static void rsnd_src_halt(struct rsnd_mod *mod)
{
--- -- rsnd_mod_write(mod, SRC_SRCIR, enable);
+++ ++ rsnd_mod_write(mod, SRC_SRCIR, 1);
+++ ++ rsnd_mod_write(mod, SRC_SWRSR, 0);
}
static struct dma_chan *rsnd_src_dma_req(struct rsnd_dai_stream *io,
is_play ? "rx" : "tx");
}
--- --int rsnd_src_ssiu_start(struct rsnd_mod *ssi_mod,
--- -- struct rsnd_dai_stream *io,
--- -- int use_busif)
--- --{
--- -- struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
--- -- int ssi_id = rsnd_mod_id(ssi_mod);
--- --
--- -- /*
--- -- * SSI_MODE0
--- -- */
--- -- rsnd_mod_bset(ssi_mod, SSI_MODE0, (1 << ssi_id),
--- -- !use_busif << ssi_id);
--- --
--- -- /*
--- -- * SSI_MODE1
--- -- */
-- -- if (rsnd_ssi_is_pin_sharing(io)) {
- if (rsnd_ssi_is_pin_sharing(ssi_mod)) {
--- -- int shift = -1;
--- -- switch (ssi_id) {
--- -- case 1:
--- -- shift = 0;
--- -- break;
--- -- case 2:
--- -- shift = 2;
--- -- break;
--- -- case 4:
--- -- shift = 16;
--- -- break;
--- -- }
--- --
--- -- if (shift >= 0)
--- -- rsnd_mod_bset(ssi_mod, SSI_MODE1,
--- -- 0x3 << shift,
--- -- rsnd_rdai_is_clk_master(rdai) ?
--- -- 0x2 << shift : 0x1 << shift);
--- -- }
--- --
--- -- /*
--- -- * DMA settings for SSIU
--- -- */
--- -- if (use_busif) {
--- -- u32 val = rsnd_get_dalign(ssi_mod, io);
--- --
--- -- rsnd_mod_write(ssi_mod, SSI_BUSIF_ADINR,
--- -- rsnd_get_adinr_bit(ssi_mod, io));
--- -- rsnd_mod_write(ssi_mod, SSI_BUSIF_MODE, 1);
--- -- rsnd_mod_write(ssi_mod, SSI_CTRL, 0x1);
--- --
--- -- rsnd_mod_write(ssi_mod, SSI_BUSIF_DALIGN, val);
--- -- }
--- --
--- -- return 0;
--- --}
--- --
--- --int rsnd_src_ssiu_stop(struct rsnd_mod *ssi_mod,
--- -- struct rsnd_dai_stream *io)
--- --{
--- -- /*
--- -- * DMA settings for SSIU
--- -- */
--- -- rsnd_mod_write(ssi_mod, SSI_CTRL, 0);
--- --
--- -- return 0;
--- --}
--- --
--- --int rsnd_src_ssi_irq_enable(struct rsnd_mod *ssi_mod)
--- --{
--- -- struct rsnd_priv *priv = rsnd_mod_to_priv(ssi_mod);
--- --
--- -- if (rsnd_is_gen1(priv))
--- -- return 0;
--- --
--- -- /* enable SSI interrupt if Gen2 */
--- -- rsnd_mod_write(ssi_mod, SSI_INT_ENABLE,
--- -- rsnd_ssi_is_dma_mode(ssi_mod) ?
--- -- 0x0e000000 : 0x0f000000);
--- --
--- -- return 0;
--- --}
--- --
--- --int rsnd_src_ssi_irq_disable(struct rsnd_mod *ssi_mod)
--- --{
--- -- struct rsnd_priv *priv = rsnd_mod_to_priv(ssi_mod);
--- --
--- -- if (rsnd_is_gen1(priv))
--- -- return 0;
--- --
--- -- /* disable SSI interrupt if Gen2 */
--- -- rsnd_mod_write(ssi_mod, SSI_INT_ENABLE, 0x00000000);
--- --
--- -- return 0;
--- --}
--- --
static u32 rsnd_src_convert_rate(struct rsnd_dai_stream *io,
struct rsnd_src *src)
{
return rate;
}
--- --static int rsnd_src_set_convert_rate(struct rsnd_mod *mod,
--- -- struct rsnd_dai_stream *io)
--- --{
--- -- struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
--- -- struct rsnd_src *src = rsnd_mod_to_src(mod);
--- -- u32 convert_rate = rsnd_src_convert_rate(io, src);
--- -- u32 fsrate = 0;
--- --
--- -- if (convert_rate)
--- -- fsrate = 0x0400000 / convert_rate * runtime->rate;
--- --
--- -- /* Set channel number and output bit length */
--- -- rsnd_mod_write(mod, SRC_ADINR, rsnd_get_adinr_bit(mod, io));
--- --
--- -- /* Enable the initial value of IFS */
--- -- if (fsrate) {
--- -- rsnd_mod_write(mod, SRC_IFSCR, 1);
--- --
--- -- /* Set initial value of IFS */
--- -- rsnd_mod_write(mod, SRC_IFSVR, fsrate);
--- -- }
--- --
--- -- /* use DMA transfer */
--- -- rsnd_mod_write(mod, SRC_BUSIF_MODE, 1);
--- --
--- -- return 0;
--- --}
--- --
static int rsnd_src_hw_params(struct rsnd_mod *mod,
struct rsnd_dai_stream *io,
struct snd_pcm_substream *substream,
struct rsnd_src *src = rsnd_mod_to_src(mod);
struct snd_soc_pcm_runtime *fe = substream->private_data;
--- -- /* default value (mainly for non-DT) */
--- -- src->convert_rate = src->info->convert_rate;
--- --
/*
* SRC assumes that it is used under DPCM if user want to use
* sampling rate convert. Then, SRC should be FE.
return 0;
}
--- --static int rsnd_src_init(struct rsnd_mod *mod,
--- -- struct rsnd_priv *priv)
--- --{
--- -- struct rsnd_src *src = rsnd_mod_to_src(mod);
--- --
-- -- rsnd_mod_power_on(mod);
- rsnd_mod_hw_start(mod);
--- --
--- -- rsnd_src_soft_reset(mod);
--- --
--- -- rsnd_src_initialize_lock(mod);
--- --
--- -- src->err = 0;
--- --
--- -- /* reset sync convert_rate */
--- -- src->sync.val = 0;
--- --
--- -- return 0;
--- --}
--- --
--- --static int rsnd_src_quit(struct rsnd_mod *mod,
--- -- struct rsnd_dai_stream *io,
--- -- struct rsnd_priv *priv)
+++ ++static void rsnd_src_set_convert_rate(struct rsnd_dai_stream *io,
+++ ++ struct rsnd_mod *mod)
{
--- -- struct rsnd_src *src = rsnd_mod_to_src(mod);
+++ ++ struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
struct device *dev = rsnd_priv_to_dev(priv);
+++ ++ struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
+++ ++ struct rsnd_src *src = rsnd_mod_to_src(mod);
+++ ++ u32 convert_rate = rsnd_src_convert_rate(io, src);
+++ ++ u32 ifscr, fsrate, adinr;
+++ ++ u32 cr, route;
+++ ++ u32 bsdsr, bsisr;
+++ ++ uint ratio;
-- -- rsnd_mod_power_off(mod);
- rsnd_mod_hw_stop(mod);
--- --
--- -- if (src->err)
--- -- dev_warn(dev, "%s[%d] under/over flow err = %d\n",
--- -- rsnd_mod_name(mod), rsnd_mod_id(mod), src->err);
--- --
--- -- src->convert_rate = 0;
--- --
--- -- /* reset sync convert_rate */
--- -- src->sync.val = 0;
--- --
--- -- return 0;
--- --}
--- --
--- --static int rsnd_src_start(struct rsnd_mod *mod)
--- --{
--- -- rsnd_src_initialize_unlock(mod);
--- --
--- -- return 0;
--- --}
--- --
--- --static int rsnd_src_stop(struct rsnd_mod *mod)
--- --{
--- -- /* nothing to do */
--- -- return 0;
--- --}
+++ ++ if (!runtime)
+++ ++ return;
--- --/*
--- -- * Gen1 functions
--- -- */
--- --static int rsnd_src_set_route_gen1(struct rsnd_dai_stream *io,
--- -- struct rsnd_mod *mod)
--- --{
--- -- struct src_route_config {
--- -- u32 mask;
--- -- int shift;
--- -- } routes[] = {
--- -- { 0xF, 0, }, /* 0 */
--- -- { 0xF, 4, }, /* 1 */
--- -- { 0xF, 8, }, /* 2 */
--- -- { 0x7, 12, }, /* 3 */
--- -- { 0x7, 16, }, /* 4 */
--- -- { 0x7, 20, }, /* 5 */
--- -- { 0x7, 24, }, /* 6 */
--- -- { 0x3, 28, }, /* 7 */
--- -- { 0x3, 30, }, /* 8 */
--- -- };
--- -- u32 mask;
--- -- u32 val;
--- -- int id;
+++ ++ /* 6 - 1/6 are very enough ratio for SRC_BSDSR */
+++ ++ if (!convert_rate)
+++ ++ ratio = 0;
+++ ++ else if (convert_rate > runtime->rate)
+++ ++ ratio = 100 * convert_rate / runtime->rate;
+++ ++ else
+++ ++ ratio = 100 * runtime->rate / convert_rate;
--- -- id = rsnd_mod_id(mod);
--- -- if (id < 0 || id >= ARRAY_SIZE(routes))
--- -- return -EIO;
+++ ++ if (ratio > 600) {
+++ ++ dev_err(dev, "FSO/FSI ratio error\n");
+++ ++ return;
+++ ++ }
/*
--- -- * SRC_ROUTE_SELECT
+++ ++ * SRC_ADINR
*/
--- -- val = rsnd_io_is_play(io) ? 0x1 : 0x2;
--- -- val = val << routes[id].shift;
--- -- mask = routes[id].mask << routes[id].shift;
--- --
--- -- rsnd_mod_bset(mod, SRC_ROUTE_SEL, mask, val);
--- --
--- -- return 0;
--- --}
--- --
--- --static int rsnd_src_set_convert_timing_gen1(struct rsnd_dai_stream *io,
--- -- struct rsnd_mod *mod)
--- --{
--- -- struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
--- -- struct rsnd_src *src = rsnd_mod_to_src(mod);
--- -- struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
--- -- u32 convert_rate = rsnd_src_convert_rate(io, src);
--- -- u32 mask;
--- -- u32 val;
--- -- int shift;
--- -- int id = rsnd_mod_id(mod);
--- -- int ret;
+++ ++ adinr = rsnd_get_adinr_bit(mod, io) |
+++ ++ rsnd_get_adinr_chan(mod, io);
/*
--- -- * SRC_TIMING_SELECT
+++ ++ * SRC_IFSCR / SRC_IFSVR
*/
--- -- shift = (id % 4) * 8;
--- -- mask = 0x1F << shift;
+++ ++ ifscr = 0;
+++ ++ fsrate = 0;
+++ ++ if (convert_rate) {
+++ ++ ifscr = 1;
+++ ++ fsrate = 0x0400000 / convert_rate * runtime->rate;
+++ ++ }
/*
--- -- * ADG is used as source clock if SRC was used,
--- -- * then, SSI WS is used as destination clock.
--- -- * SSI WS is used as source clock if SRC is not used
--- -- * (when playback, source/destination become reverse when capture)
+++ ++ * SRC_SRCCR / SRC_ROUTE_MODE0
*/
--- -- ret = 0;
+++ ++ cr = 0x00011110;
+++ ++ route = 0x0;
if (convert_rate) {
--- -- /* use ADG */
--- -- val = 0;
--- -- ret = rsnd_adg_set_convert_clk_gen1(priv, mod,
--- -- runtime->rate,
--- -- convert_rate);
--- -- } else if (8 == id) {
--- -- /* use SSI WS, but SRU8 is special */
--- -- val = id << shift;
--- -- } else {
--- -- /* use SSI WS */
--- -- val = (id + 1) << shift;
--- -- }
+++ ++ route = 0x1;
--- -- if (ret < 0)
--- -- return ret;
+++ ++ if (rsnd_enable_sync_convert(src)) {
+++ ++ cr |= 0x1;
+++ ++ route |= rsnd_io_is_play(io) ?
+++ ++ (0x1 << 24) : (0x1 << 25);
+++ ++ }
+++ ++ }
--- -- switch (id / 4) {
--- -- case 0:
--- -- rsnd_mod_bset(mod, SRC_TMG_SEL0, mask, val);
--- -- break;
--- -- case 1:
--- -- rsnd_mod_bset(mod, SRC_TMG_SEL1, mask, val);
+++ ++ /*
+++ ++ * SRC_BSDSR / SRC_BSISR
+++ ++ */
+++ ++ switch (rsnd_mod_id(mod)) {
+++ ++ case 5:
+++ ++ case 6:
+++ ++ case 7:
+++ ++ case 8:
+++ ++ bsdsr = 0x02400000; /* 6 - 1/6 */
+++ ++ bsisr = 0x00100060; /* 6 - 1/6 */
break;
--- -- case 2:
--- -- rsnd_mod_bset(mod, SRC_TMG_SEL2, mask, val);
+++ ++ default:
+++ ++ bsdsr = 0x01800000; /* 6 - 1/6 */
+++ ++ bsisr = 0x00100060 ;/* 6 - 1/6 */
break;
}
--- -- return 0;
--- --}
--- --
--- --static int rsnd_src_set_convert_rate_gen1(struct rsnd_mod *mod,
--- -- struct rsnd_dai_stream *io)
--- --{
--- -- struct rsnd_src *src = rsnd_mod_to_src(mod);
--- -- int ret;
--- --
--- -- ret = rsnd_src_set_convert_rate(mod, io);
--- -- if (ret < 0)
--- -- return ret;
--- --
--- -- /* Select SRC mode (fixed value) */
--- -- rsnd_mod_write(mod, SRC_SRCCR, 0x00010110);
--- --
--- -- /* Set the restriction value of the FS ratio (98%) */
--- -- rsnd_mod_write(mod, SRC_MNFSR,
--- -- rsnd_mod_read(mod, SRC_IFSVR) / 100 * 98);
--- --
--- -- /* Gen1/Gen2 are not compatible */
--- -- if (rsnd_src_convert_rate(io, src))
--- -- rsnd_mod_write(mod, SRC_ROUTE_MODE0, 1);
--- --
--- -- /* no SRC_BFSSR settings, since SRC_SRCCR::BUFMD is 0 */
--- --
--- -- return 0;
--- --}
--- --
--- --static int rsnd_src_init_gen1(struct rsnd_mod *mod,
--- -- struct rsnd_dai_stream *io,
--- -- struct rsnd_priv *priv)
--- --{
--- -- int ret;
--- --
--- -- ret = rsnd_src_init(mod, priv);
--- -- if (ret < 0)
--- -- return ret;
--- --
--- -- ret = rsnd_src_set_route_gen1(io, mod);
--- -- if (ret < 0)
--- -- return ret;
--- --
--- -- ret = rsnd_src_set_convert_rate_gen1(mod, io);
--- -- if (ret < 0)
--- -- return ret;
--- --
--- -- ret = rsnd_src_set_convert_timing_gen1(io, mod);
--- -- if (ret < 0)
--- -- return ret;
--- --
--- -- return 0;
--- --}
--- --
--- --static int rsnd_src_start_gen1(struct rsnd_mod *mod,
--- -- struct rsnd_dai_stream *io,
--- -- struct rsnd_priv *priv)
--- --{
--- -- int id = rsnd_mod_id(mod);
--- --
--- -- rsnd_mod_bset(mod, SRC_ROUTE_CTRL, (1 << id), (1 << id));
--- --
--- -- return rsnd_src_start(mod);
--- --}
--- --
--- --static int rsnd_src_stop_gen1(struct rsnd_mod *mod,
--- -- struct rsnd_dai_stream *io,
--- -- struct rsnd_priv *priv)
--- --{
--- -- int id = rsnd_mod_id(mod);
+++ ++ rsnd_mod_write(mod, SRC_SRCIR, 1); /* initialize */
+++ ++ rsnd_mod_write(mod, SRC_ADINR, adinr);
+++ ++ rsnd_mod_write(mod, SRC_IFSCR, ifscr);
+++ ++ rsnd_mod_write(mod, SRC_IFSVR, fsrate);
+++ ++ rsnd_mod_write(mod, SRC_SRCCR, cr);
+++ ++ rsnd_mod_write(mod, SRC_BSDSR, bsdsr);
+++ ++ rsnd_mod_write(mod, SRC_BSISR, bsisr);
+++ ++ rsnd_mod_write(mod, SRC_SRCIR, 0); /* cancel initialize */
--- -- rsnd_mod_bset(mod, SRC_ROUTE_CTRL, (1 << id), 0);
+++ ++ rsnd_mod_write(mod, SRC_ROUTE_MODE0, route);
+++ ++ rsnd_mod_write(mod, SRC_I_BUSIF_MODE, 1);
+++ ++ rsnd_mod_write(mod, SRC_O_BUSIF_MODE, 1);
+++ ++ rsnd_mod_write(mod, SRC_BUSIF_DALIGN, rsnd_get_dalign(mod, io));
--- -- return rsnd_src_stop(mod);
+++ ++ if (convert_rate)
+++ ++ rsnd_adg_set_convert_clk_gen2(mod, io,
+++ ++ runtime->rate,
+++ ++ convert_rate);
+++ ++ else
+++ ++ rsnd_adg_set_convert_timing_gen2(mod, io);
}
--- --static struct rsnd_mod_ops rsnd_src_gen1_ops = {
--- -- .name = SRC_NAME,
--- -- .dma_req = rsnd_src_dma_req,
--- -- .init = rsnd_src_init_gen1,
--- -- .quit = rsnd_src_quit,
--- -- .start = rsnd_src_start_gen1,
--- -- .stop = rsnd_src_stop_gen1,
--- -- .hw_params = rsnd_src_hw_params,
--- --};
--- --
--- --/*
--- -- * Gen2 functions
--- -- */
--- --#define rsnd_src_irq_enable_gen2(mod) rsnd_src_irq_ctrol_gen2(mod, 1)
--- --#define rsnd_src_irq_disable_gen2(mod) rsnd_src_irq_ctrol_gen2(mod, 0)
--- --static void rsnd_src_irq_ctrol_gen2(struct rsnd_mod *mod, int enable)
+++ ++#define rsnd_src_irq_enable(mod) rsnd_src_irq_ctrol(mod, 1)
+++ ++#define rsnd_src_irq_disable(mod) rsnd_src_irq_ctrol(mod, 0)
+++ ++static void rsnd_src_irq_ctrol(struct rsnd_mod *mod, int enable)
{
struct rsnd_src *src = rsnd_mod_to_src(mod);
u32 sys_int_val, int_val, sys_int_mask;
--- -- int irq = src->info->irq;
+++ ++ int irq = src->irq;
int id = rsnd_mod_id(mod);
sys_int_val =
/*
* IRQ is not supported on non-DT
* see
--- -- * rsnd_src_probe_gen2()
+++ ++ * rsnd_src_probe_()
*/
if ((irq <= 0) || !enable) {
sys_int_val = 0;
rsnd_mod_bset(mod, SCU_SYS_INT_EN1, sys_int_mask, sys_int_val);
}
--- --static void rsnd_src_error_clear_gen2(struct rsnd_mod *mod)
+++ ++static void rsnd_src_status_clear(struct rsnd_mod *mod)
{
u32 val = OUF_SRC(rsnd_mod_id(mod));
rsnd_mod_bset(mod, SCU_SYS_STATUS1, val, val);
}
--- --static bool rsnd_src_error_record_gen2(struct rsnd_mod *mod)
+++ ++static bool rsnd_src_record_error(struct rsnd_mod *mod)
{
struct rsnd_src *src = rsnd_mod_to_src(mod);
u32 val0, val1;
ret = true;
}
--- -- /* clear error static */
--- -- rsnd_src_error_clear_gen2(mod);
--- --
return ret;
}
--- --static int _rsnd_src_start_gen2(struct rsnd_mod *mod,
--- -- struct rsnd_dai_stream *io)
+++ ++static int rsnd_src_start(struct rsnd_mod *mod,
+++ ++ struct rsnd_dai_stream *io,
+++ ++ struct rsnd_priv *priv)
{
struct rsnd_src *src = rsnd_mod_to_src(mod);
u32 val;
--- -- val = rsnd_get_dalign(mod, io);
--- --
--- -- rsnd_mod_write(mod, SRC_BUSIF_DALIGN, val);
--- --
/*
* WORKAROUND
*
rsnd_mod_write(mod, SRC_CTRL, val);
--- -- rsnd_src_error_clear_gen2(mod);
--- --
--- -- rsnd_src_start(mod);
+++ ++ return 0;
+++ ++}
--- -- rsnd_src_irq_enable_gen2(mod);
+++ ++static int rsnd_src_stop(struct rsnd_mod *mod,
+++ ++ struct rsnd_dai_stream *io,
+++ ++ struct rsnd_priv *priv)
+++ ++{
+++ ++ /*
+++ ++ * stop SRC output only
+++ ++ * see rsnd_src_quit
+++ ++ */
+++ ++ rsnd_mod_write(mod, SRC_CTRL, 0x01);
return 0;
}
--- --static int _rsnd_src_stop_gen2(struct rsnd_mod *mod)
+++ ++static int rsnd_src_init(struct rsnd_mod *mod,
+++ ++ struct rsnd_dai_stream *io,
+++ ++ struct rsnd_priv *priv)
{
--- -- rsnd_src_irq_disable_gen2(mod);
+++ ++ struct rsnd_src *src = rsnd_mod_to_src(mod);
--- -- rsnd_mod_write(mod, SRC_CTRL, 0);
+++ ++ rsnd_mod_power_on(mod);
+ +
- -- rsnd_src_error_record_gen2(mod);
+++ ++ rsnd_src_activation(mod);
++ ++
- rsnd_src_error_record_gen2(mod);
+++ ++ rsnd_src_set_convert_rate(io, mod);
++ ++
- rsnd_src_error_record_gen2(mod);
+++ ++ rsnd_src_status_clear(mod);
+++ ++
+++ ++ rsnd_src_irq_enable(mod);
+++ ++
+++ ++ src->err = 0;
++ ++
- return rsnd_src_stop(mod);
+++ ++ /* reset sync convert_rate */
+++ ++ src->sync.val = 0;
+
-- -- return rsnd_src_stop(mod);
+++ ++ return 0;
}
--- --static void __rsnd_src_interrupt_gen2(struct rsnd_mod *mod,
--- -- struct rsnd_dai_stream *io)
+++ ++static int rsnd_src_quit(struct rsnd_mod *mod,
+++ ++ struct rsnd_dai_stream *io,
+++ ++ struct rsnd_priv *priv)
{
--- -- struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
- -
- - spin_lock(&priv->lock);
+++ ++ struct rsnd_src *src = rsnd_mod_to_src(mod);
+++ ++ struct device *dev = rsnd_priv_to_dev(priv);
- - /* ignore all cases if not working */
- - if (!rsnd_io_is_working(io))
- - goto rsnd_src_interrupt_gen2_out;
- -- spin_lock(&priv->lock);
+++ ++ rsnd_src_irq_disable(mod);
- - if (rsnd_src_error_record_gen2(mod)) {
- - struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
- - struct rsnd_src *src = rsnd_mod_to_src(mod);
- - struct device *dev = rsnd_priv_to_dev(priv);
- -- /* ignore all cases if not working */
- -- if (!rsnd_io_is_working(io))
- -- goto rsnd_src_interrupt_gen2_out;
+++ ++ /* stop both out/in */
+++ ++ rsnd_mod_write(mod, SRC_CTRL, 0);
- - dev_dbg(dev, "%s[%d] restart\n",
- - rsnd_mod_name(mod), rsnd_mod_id(mod));
- -- if (rsnd_src_error_record_gen2(mod)) {
- -- struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
- -- struct rsnd_src *src = rsnd_mod_to_src(mod);
- -- struct device *dev = rsnd_priv_to_dev(priv);
+++ ++ rsnd_src_halt(mod);
- -- dev_dbg(dev, "%s[%d] restart\n",
- -- rsnd_mod_name(mod), rsnd_mod_id(mod));
- --
--- -- _rsnd_src_stop_gen2(mod);
--- -- if (src->err < 1024)
--- -- _rsnd_src_start_gen2(mod, io);
--- -- else
--- -- dev_warn(dev, "no more SRC restart\n");
--- -- }
+++ ++ rsnd_mod_power_off(mod);
--- --rsnd_src_interrupt_gen2_out:
--- -- spin_unlock(&priv->lock);
--- --}
+++ ++ if (src->err)
+++ ++ dev_warn(dev, "%s[%d] under/over flow err = %d\n",
+++ ++ rsnd_mod_name(mod), rsnd_mod_id(mod), src->err);
--- --static irqreturn_t rsnd_src_interrupt_gen2(int irq, void *data)
--- --{
--- -- struct rsnd_mod *mod = data;
+++ ++ src->convert_rate = 0;
--- -- rsnd_mod_interrupt(mod, __rsnd_src_interrupt_gen2);
+++ ++ /* reset sync convert_rate */
+++ ++ src->sync.val = 0;
--- -- return IRQ_HANDLED;
+++ ++ return 0;
}
--- --static int rsnd_src_set_convert_rate_gen2(struct rsnd_mod *mod,
--- -- struct rsnd_dai_stream *io)
+++ ++static void __rsnd_src_interrupt(struct rsnd_mod *mod,
+++ ++ struct rsnd_dai_stream *io)
{
struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
--- -- struct device *dev = rsnd_priv_to_dev(priv);
--- -- struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
struct rsnd_src *src = rsnd_mod_to_src(mod);
--- -- u32 convert_rate = rsnd_src_convert_rate(io, src);
--- -- u32 cr, route;
--- -- uint ratio;
--- -- int ret;
+++ ++ struct device *dev = rsnd_priv_to_dev(priv);
--- -- /* 6 - 1/6 are very enough ratio for SRC_BSDSR */
--- -- if (!convert_rate)
--- -- ratio = 0;
--- -- else if (convert_rate > runtime->rate)
--- -- ratio = 100 * convert_rate / runtime->rate;
--- -- else
--- -- ratio = 100 * runtime->rate / convert_rate;
+++ ++ spin_lock(&priv->lock);
--- -- if (ratio > 600) {
--- -- dev_err(dev, "FSO/FSI ratio error\n");
--- -- return -EINVAL;
--- -- }
+++ ++ /* ignore all cases if not working */
+++ ++ if (!rsnd_io_is_working(io))
+++ ++ goto rsnd_src_interrupt_out;
--- -- ret = rsnd_src_set_convert_rate(mod, io);
--- -- if (ret < 0)
--- -- return ret;
+++ ++ if (rsnd_src_record_error(mod)) {
--- -- cr = 0x00011110;
--- -- route = 0x0;
--- -- if (convert_rate) {
--- -- route = 0x1;
+++ ++ dev_dbg(dev, "%s[%d] restart\n",
+++ ++ rsnd_mod_name(mod), rsnd_mod_id(mod));
--- -- if (rsnd_enable_sync_convert(src)) {
--- -- cr |= 0x1;
--- -- route |= rsnd_io_is_play(io) ?
--- -- (0x1 << 24) : (0x1 << 25);
--- -- }
+++ ++ rsnd_src_stop(mod, io, priv);
+++ ++ rsnd_src_start(mod, io, priv);
}
--- -- rsnd_mod_write(mod, SRC_SRCCR, cr);
--- -- rsnd_mod_write(mod, SRC_ROUTE_MODE0, route);
+++ ++ if (src->err > 1024) {
+++ ++ rsnd_src_irq_disable(mod);
--- -- switch (rsnd_mod_id(mod)) {
--- -- case 5:
--- -- case 6:
--- -- case 7:
--- -- case 8:
--- -- rsnd_mod_write(mod, SRC_BSDSR, 0x02400000);
--- -- break;
--- -- default:
--- -- rsnd_mod_write(mod, SRC_BSDSR, 0x01800000);
--- -- break;
+++ ++ dev_warn(dev, "no more %s[%d] restart\n",
+++ ++ rsnd_mod_name(mod), rsnd_mod_id(mod));
}
--- -- rsnd_mod_write(mod, SRC_BSISR, 0x00100060);
+++ ++ rsnd_src_status_clear(mod);
+++ ++rsnd_src_interrupt_out:
--- -- return 0;
+++ ++ spin_unlock(&priv->lock);
}
--- --static int rsnd_src_set_convert_timing_gen2(struct rsnd_dai_stream *io,
--- -- struct rsnd_mod *mod)
+++ ++static irqreturn_t rsnd_src_interrupt(int irq, void *data)
{
--- -- struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
--- -- struct rsnd_src *src = rsnd_mod_to_src(mod);
--- -- u32 convert_rate = rsnd_src_convert_rate(io, src);
--- -- int ret;
+++ ++ struct rsnd_mod *mod = data;
--- -- if (convert_rate)
--- -- ret = rsnd_adg_set_convert_clk_gen2(mod, io,
--- -- runtime->rate,
--- -- convert_rate);
--- -- else
--- -- ret = rsnd_adg_set_convert_timing_gen2(mod, io);
+++ ++ rsnd_mod_interrupt(mod, __rsnd_src_interrupt);
--- -- return ret;
+++ ++ return IRQ_HANDLED;
}
--- --static int rsnd_src_probe_gen2(struct rsnd_mod *mod,
--- -- struct rsnd_dai_stream *io,
--- -- struct rsnd_priv *priv)
+++ ++static int rsnd_src_probe_(struct rsnd_mod *mod,
+++ ++ struct rsnd_dai_stream *io,
+++ ++ struct rsnd_priv *priv)
{
struct rsnd_src *src = rsnd_mod_to_src(mod);
struct device *dev = rsnd_priv_to_dev(priv);
--- -- int irq = src->info->irq;
+++ ++ int irq = src->irq;
int ret;
if (irq > 0) {
/*
* IRQ is not supported on non-DT
* see
--- -- * rsnd_src_irq_enable_gen2()
+++ ++ * rsnd_src_irq_enable()
*/
ret = devm_request_irq(dev, irq,
--- -- rsnd_src_interrupt_gen2,
+++ ++ rsnd_src_interrupt,
IRQF_SHARED,
dev_name(dev), mod);
if (ret)
return ret;
}
--- -- ret = rsnd_dma_init(io,
--- -- rsnd_mod_to_dma(mod),
--- -- src->info->dma_id);
+++ ++ src->dma = rsnd_dma_attach(io, mod, 0);
+++ ++ if (IS_ERR(src->dma))
+++ ++ return PTR_ERR(src->dma);
return ret;
}
--- --static int rsnd_src_remove_gen2(struct rsnd_mod *mod,
--- -- struct rsnd_dai_stream *io,
--- -- struct rsnd_priv *priv)
--- --{
--- -- rsnd_dma_quit(io, rsnd_mod_to_dma(mod));
--- --
--- -- return 0;
--- --}
--- --
--- --static int rsnd_src_init_gen2(struct rsnd_mod *mod,
--- -- struct rsnd_dai_stream *io,
--- -- struct rsnd_priv *priv)
--- --{
--- -- int ret;
--- --
--- -- ret = rsnd_src_init(mod, priv);
--- -- if (ret < 0)
--- -- return ret;
--- --
--- -- ret = rsnd_src_set_convert_rate_gen2(mod, io);
--- -- if (ret < 0)
--- -- return ret;
--- --
--- -- ret = rsnd_src_set_convert_timing_gen2(io, mod);
--- -- if (ret < 0)
--- -- return ret;
--- --
--- -- return 0;
--- --}
--- --
--- --static int rsnd_src_start_gen2(struct rsnd_mod *mod,
--- -- struct rsnd_dai_stream *io,
--- -- struct rsnd_priv *priv)
--- --{
--- -- rsnd_dma_start(io, rsnd_mod_to_dma(mod));
--- --
--- -- return _rsnd_src_start_gen2(mod, io);
--- --}
--- --
--- --static int rsnd_src_stop_gen2(struct rsnd_mod *mod,
--- -- struct rsnd_dai_stream *io,
--- -- struct rsnd_priv *priv)
--- --{
--- -- int ret;
--- --
--- -- ret = _rsnd_src_stop_gen2(mod);
--- --
--- -- rsnd_dma_stop(io, rsnd_mod_to_dma(mod));
--- --
--- -- return ret;
--- --}
--- --
--- --static void rsnd_src_reconvert_update(struct rsnd_dai_stream *io,
--- -- struct rsnd_mod *mod)
--- --{
--- -- struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
--- -- struct rsnd_src *src = rsnd_mod_to_src(mod);
--- -- u32 convert_rate = rsnd_src_convert_rate(io, src);
--- -- u32 fsrate;
--- --
--- -- if (!runtime)
--- -- return;
--- --
--- -- if (!convert_rate)
--- -- convert_rate = runtime->rate;
--- --
--- -- fsrate = 0x0400000 / convert_rate * runtime->rate;
--- --
--- -- /* update IFS */
--- -- rsnd_mod_write(mod, SRC_IFSVR, fsrate);
--- --}
--- --
-- --static int rsnd_src_pcm_new_gen2(struct rsnd_mod *mod,
++ ++static int rsnd_src_pcm_new(struct rsnd_mod *mod,
struct rsnd_dai_stream *io,
struct snd_soc_pcm_runtime *rtd)
{
- struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
+++++ struct rsnd_mod *dvc = rsnd_io_to_mod_dvc(io);
struct rsnd_src *src = rsnd_mod_to_src(mod);
int ret;
*/
/*
- * Gen1 is not supported
+ * SRC sync convert needs clock master
*/
- if (rsnd_is_gen1(priv))
+ if (!rsnd_rdai_is_clk_master(rdai))
return 0;
- * SRC sync convert needs clock master
+ +++ /*
- if (!rsnd_rdai_is_clk_master(rdai))
+++++ * SRC In doesn't work if DVC was enabled
+ +++ */
+++++ if (dvc && !rsnd_io_is_play(io))
+ +++ return 0;
+ +++
/*
* enable sync convert
*/
rsnd_io_is_play(io) ?
"SRC Out Rate Switch" :
"SRC In Rate Switch",
--- -- rsnd_src_reconvert_update,
+++ ++ rsnd_src_set_convert_rate,
&src->sen, 1);
if (ret < 0)
return ret;
rsnd_io_is_play(io) ?
"SRC Out Rate" :
"SRC In Rate",
--- -- rsnd_src_reconvert_update,
+++ ++ rsnd_src_set_convert_rate,
&src->sync, 192000);
return ret;
}
--- --static struct rsnd_mod_ops rsnd_src_gen2_ops = {
+++ ++static struct rsnd_mod_ops rsnd_src_ops = {
.name = SRC_NAME,
.dma_req = rsnd_src_dma_req,
--- -- .probe = rsnd_src_probe_gen2,
--- -- .remove = rsnd_src_remove_gen2,
--- -- .init = rsnd_src_init_gen2,
+++ ++ .probe = rsnd_src_probe_,
+++ ++ .init = rsnd_src_init,
.quit = rsnd_src_quit,
--- -- .start = rsnd_src_start_gen2,
--- -- .stop = rsnd_src_stop_gen2,
+++ ++ .start = rsnd_src_start,
+++ ++ .stop = rsnd_src_stop,
.hw_params = rsnd_src_hw_params,
-- -- .pcm_new = rsnd_src_pcm_new_gen2,
++ ++ .pcm_new = rsnd_src_pcm_new,
};
struct rsnd_mod *rsnd_src_mod_get(struct rsnd_priv *priv, int id)
if (WARN_ON(id < 0 || id >= rsnd_src_nr(priv)))
id = 0;
-- -- return rsnd_mod_get((struct rsnd_src *)(priv->src) + id);
- return &((struct rsnd_src *)(priv->src) + id)->mod;
+++ ++ return rsnd_mod_get(rsnd_src_get(priv, id));
}
--- --static void rsnd_of_parse_src(struct platform_device *pdev,
--- -- const struct rsnd_of_data *of_data,
--- -- struct rsnd_priv *priv)
+++ ++int rsnd_src_probe(struct rsnd_priv *priv)
{
--- -- struct device_node *src_node;
+++ ++ struct device_node *node;
struct device_node *np;
--- -- struct rcar_snd_info *info = rsnd_priv_to_info(priv);
--- -- struct rsnd_src_platform_info *src_info;
--- -- struct device *dev = &pdev->dev;
--- -- int nr, i;
--- --
--- -- if (!of_data)
--- -- return;
--- --
--- -- src_node = rsnd_src_of_node(priv);
--- -- if (!src_node)
--- -- return;
--- --
--- -- nr = of_get_child_count(src_node);
--- -- if (!nr)
--- -- goto rsnd_of_parse_src_end;
--- --
--- -- src_info = devm_kzalloc(dev,
--- -- sizeof(struct rsnd_src_platform_info) * nr,
--- -- GFP_KERNEL);
--- -- if (!src_info) {
--- -- dev_err(dev, "src info allocation error\n");
--- -- goto rsnd_of_parse_src_end;
--- -- }
--- --
--- -- info->src_info = src_info;
--- -- info->src_info_nr = nr;
--- --
--- -- i = 0;
--- -- for_each_child_of_node(src_node, np) {
--- -- src_info[i].irq = irq_of_parse_and_map(np, 0);
--- --
--- -- i++;
--- -- }
--- --
--- --rsnd_of_parse_src_end:
--- -- of_node_put(src_node);
--- --}
--- --
--- --int rsnd_src_probe(struct platform_device *pdev,
--- -- const struct rsnd_of_data *of_data,
--- -- struct rsnd_priv *priv)
--- --{
--- -- struct rcar_snd_info *info = rsnd_priv_to_info(priv);
struct device *dev = rsnd_priv_to_dev(priv);
struct rsnd_src *src;
--- -- struct rsnd_mod_ops *ops;
struct clk *clk;
char name[RSND_SRC_NAME_SIZE];
int i, nr, ret;
--- -- ops = NULL;
-- -- if (rsnd_is_gen1(priv)) {
-- -- ops = &rsnd_src_gen1_ops;
-- -- dev_warn(dev, "Gen1 support will be removed soon\n");
-- -- }
-- -- if (rsnd_is_gen2(priv))
-- -- ops = &rsnd_src_gen2_ops;
-- -- if (!ops) {
-- -- dev_err(dev, "unknown Generation\n");
-- -- return -EIO;
-- -- }
+++ ++ /* This driver doesn't support Gen1 at this point */
++ ++ if (rsnd_is_gen1(priv))
- ops = &rsnd_src_gen1_ops;
- if (rsnd_is_gen2(priv))
- ops = &rsnd_src_gen2_ops;
- if (!ops) {
- dev_err(dev, "unknown Generation\n");
- return -EIO;
- }
+++ ++ return 0;
--- -- rsnd_of_parse_src(pdev, of_data, priv);
+++ ++ node = rsnd_src_of_node(priv);
+++ ++ if (!node)
+++ ++ return 0; /* not used is not error */
--- -- /*
--- -- * init SRC
--- -- */
--- -- nr = info->src_info_nr;
--- -- if (!nr)
--- -- return 0;
+++ ++ nr = of_get_child_count(node);
+++ ++ if (!nr) {
+++ ++ ret = -EINVAL;
+++ ++ goto rsnd_src_probe_done;
+++ ++ }
src = devm_kzalloc(dev, sizeof(*src) * nr, GFP_KERNEL);
--- -- if (!src)
--- -- return -ENOMEM;
+++ ++ if (!src) {
+++ ++ ret = -ENOMEM;
+++ ++ goto rsnd_src_probe_done;
+++ ++ }
priv->src_nr = nr;
priv->src = src;
--- -- for_each_rsnd_src(src, priv, i) {
+++ ++ i = 0;
+++ ++ for_each_child_of_node(node, np) {
+++ ++ src = rsnd_src_get(priv, i);
+++ ++
snprintf(name, RSND_SRC_NAME_SIZE, "%s.%d",
SRC_NAME, i);
--- -- clk = devm_clk_get(dev, name);
--- -- if (IS_ERR(clk))
--- -- return PTR_ERR(clk);
+++ ++ src->irq = irq_of_parse_and_map(np, 0);
+++ ++ if (!src->irq) {
+++ ++ ret = -EINVAL;
+++ ++ goto rsnd_src_probe_done;
+++ ++ }
--- -- src->info = &info->src_info[i];
+++ ++ clk = devm_clk_get(dev, name);
+++ ++ if (IS_ERR(clk)) {
+++ ++ ret = PTR_ERR(clk);
+++ ++ goto rsnd_src_probe_done;
+++ ++ }
-- -- ret = rsnd_mod_init(priv, rsnd_mod_get(src), ops, clk, RSND_MOD_SRC, i);
- ret = rsnd_mod_init(priv, &src->mod, ops, clk, RSND_MOD_SRC, i);
+++ ++ ret = rsnd_mod_init(priv, rsnd_mod_get(src),
+++ ++ &rsnd_src_ops, clk, RSND_MOD_SRC, i);
if (ret)
--- -- return ret;
+++ ++ goto rsnd_src_probe_done;
+++ ++
+++ ++ i++;
}
--- -- return 0;
+++ ++ ret = 0;
+++ ++
+++ ++rsnd_src_probe_done:
+++ ++ of_node_put(node);
+++ ++
+++ ++ return ret;
}
--- --void rsnd_src_remove(struct platform_device *pdev,
--- -- struct rsnd_priv *priv)
+++ ++void rsnd_src_remove(struct rsnd_priv *priv)
{
struct rsnd_src *src;
int i;
for_each_rsnd_src(src, priv, i) {
- rsnd_mod_quit(&src->mod);
+ rsnd_mod_quit(rsnd_mod_get(src));
}
}
projects / karo-tx-linux.git / commitdiff