Re: [PATCH] ASoC: dapm: Add support for multi register mux

Takashi Iwai
2014-04-03T09:47:16Z

At Wed, 2 Apr 2014 20:11:50 -0700,
Arun Shamanna Lakshmi wrote:
>
> - Modify soc_enum struct to handle pointers for reg and mask
> - Add dapm get and put APIs for multi register mux with one hot encoding
> - Update snd_soc_dapm_update struct to support multiple reg update
>
> Signed-off-by: Arun Shamanna Lakshmi <aruns@nvidia.com>
> Signed-off-by: Songhee Baek <sbaek@nvidia.com>

I'm a bit late in the game, but I feel a bit uneasy through looking
at the whole changes. My primary question is, whether do we really
need to share the same struct soc_enum for the onehot type? What
makes hard to use a struct soc_enum_onehot for them? You need
different individual get/put for each type. We may still need to
change soc_dapm_update stuff, but it's different from sharing
soc_enum.

thanks,

Takashi

> ---
> include/sound/soc-dapm.h | 17 ++++-
> include/sound/soc.h | 34 +++++++--
> sound/soc/soc-core.c | 12 ++--
> sound/soc/soc-dapm.c | 174 +++++++++++++++++++++++++++++++++++++++-------
> 4 files changed, 197 insertions(+), 40 deletions(-)
>
> diff --git a/include/sound/soc-dapm.h b/include/sound/soc-dapm.h
> index ef78f56..ded46732 100644
> --- a/include/sound/soc-dapm.h
> +++ b/include/sound/soc-dapm.h
> @@ -305,6 +305,12 @@ struct device;
> .get = snd_soc_dapm_get_enum_double, \
> .put = snd_soc_dapm_put_enum_double, \
> .private_value = (unsigned long)&xenum }
> +#define SOC_DAPM_ENUM_ONEHOT(xname, xenum) \
> +{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
> + .info = snd_soc_info_enum_double, \
> + .get = snd_soc_dapm_get_enum_onehot, \
> + .put = snd_soc_dapm_put_enum_onehot, \
> + .private_value = (unsigned long)&xenum }
> #define SOC_DAPM_ENUM_VIRT(xname, xenum) \
> SOC_DAPM_ENUM(xname, xenum)
> #define SOC_DAPM_ENUM_EXT(xname, xenum, xget, xput) \
> @@ -378,6 +384,10 @@ int snd_soc_dapm_get_enum_double(struct snd_kcontrol *kcontrol,
> struct snd_ctl_elem_value *ucontrol);
> int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
> struct snd_ctl_elem_value *ucontrol);
> +int snd_soc_dapm_get_enum_onehot(struct snd_kcontrol *kcontrol,
> + struct snd_ctl_elem_value *ucontrol);
> +int snd_soc_dapm_put_enum_onehot(struct snd_kcontrol *kcontrol,
> + struct snd_ctl_elem_value *ucontrol);
> int snd_soc_dapm_info_pin_switch(struct snd_kcontrol *kcontrol,
> struct snd_ctl_elem_info *uinfo);
> int snd_soc_dapm_get_pin_switch(struct snd_kcontrol *kcontrol,
> @@ -590,9 +600,10 @@ struct snd_soc_dapm_widget {
>
> struct snd_soc_dapm_update {
> struct snd_kcontrol *kcontrol;
> - int reg;
> - int mask;
> - int val;
> + int reg[3];
> + int mask[3];
> + int val[3];
> + int num_regs;
> };
>
> /* DAPM context */
> diff --git a/include/sound/soc.h b/include/sound/soc.h
> index 0b83168..add326a 100644
> --- a/include/sound/soc.h
> +++ b/include/sound/soc.h
> @@ -177,18 +177,24 @@
> {.reg = xreg, .min = xmin, .max = xmax, \
> .platform_max = xmax} }
> #define SOC_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xitems, xtexts) \
> -{ .reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
> +{ .reg = &(int){(xreg)}, .shift_l = xshift_l, .shift_r = xshift_r, \
> .items = xitems, .texts = xtexts, \
> - .mask = xitems ? roundup_pow_of_two(xitems) - 1 : 0}
> + .mask = &(unsigned int){(xitems ? roundup_pow_of_two(xitems) - 1 : 0)}, \
> + .num_regs = 1, .type = SND_SOC_ENUM_NONE }
> #define SOC_ENUM_SINGLE(xreg, xshift, xitems, xtexts) \
> SOC_ENUM_DOUBLE(xreg, xshift, xshift, xitems, xtexts)
> #define SOC_ENUM_SINGLE_EXT(xitems, xtexts) \
> { .items = xitems, .texts = xtexts }
> #define SOC_VALUE_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, xitems, xtexts, xvalues) \
> -{ .reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \
> - .mask = xmask, .items = xitems, .texts = xtexts, .values = xvalues}
> +{ .reg = &(int){(xreg)}, .shift_l = xshift_l, .shift_r = xshift_r, \
> + .mask = &(unsigned int){(xmask)}, .items = xitems, .texts = xtexts, \
> + .values = xvalues, .num_regs = 1, .type = SND_SOC_ENUM_NONE }
> #define SOC_VALUE_ENUM_SINGLE(xreg, xshift, xmask, xnitmes, xtexts, xvalues) \
> SOC_VALUE_ENUM_DOUBLE(xreg, xshift, xshift, xmask, xnitmes, xtexts, xvalues)
> +#define SOC_VALUE_ENUM_ONEHOT(xregs, xmasks, xnum_regs, xitems, xtexts, xvalues) \
> +{ .reg = xregs, .mask = xmasks, .num_regs = xnum_regs, \
> + .items = xitems, .texts = xtexts, .values = xvalues, \
> + .type = SND_SOC_ENUM_ONEHOT }
> #define SOC_ENUM_SINGLE_VIRT(xitems, xtexts) \
> SOC_ENUM_SINGLE(SND_SOC_NOPM, 0, xitems, xtexts)
> #define SOC_ENUM(xname, xenum) \
> @@ -293,6 +299,9 @@
> #define SOC_VALUE_ENUM_DOUBLE_DECL(name, xreg, xshift_l, xshift_r, xmask, xtexts, xvalues) \
> const struct soc_enum name = SOC_VALUE_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, \
> ARRAY_SIZE(xtexts), xtexts, xvalues)
> +#define SOC_VALUE_ENUM_ONEHOT_DECL(name, xregs, xmasks, xnum_regs, xtexts, xvalues) \
> + const struct soc_enum name = SOC_VALUE_ENUM_ONEHOT(xregs, xmasks, xnum_regs, \
> + ARRAY_SIZE(xtexts), xtexts, xvalues)
> #define SOC_VALUE_ENUM_SINGLE_DECL(name, xreg, xshift, xmask, xtexts, xvalues) \
> SOC_VALUE_ENUM_DOUBLE_DECL(name, xreg, xshift, xshift, xmask, xtexts, xvalues)
> #define SOC_ENUM_SINGLE_VIRT_DECL(name, xtexts) \
> @@ -326,6 +335,17 @@ enum snd_soc_bias_level {
> SND_SOC_BIAS_ON = 3,
> };
>
> +/*
> + * Soc Enum Type
> + *
> + * @NONE: soc_enum type for SINGLE, DOUBLE or VIRTUAL mux
> + * @ONEHOT: soc_enum type for one hot encoding mux
> + */
> +enum snd_soc_enum_type {
> + SND_SOC_ENUM_NONE = 0,
> + SND_SOC_ENUM_ONEHOT = 1,
> +};
> +
> struct device_node;
> struct snd_jack;
> struct snd_soc_card;
> @@ -1098,13 +1118,15 @@ struct soc_mreg_control {
>
> /* enumerated kcontrol */
> struct soc_enum {
> - int reg;
> + int *reg;
> unsigned char shift_l;
> unsigned char shift_r;
> unsigned int items;
> - unsigned int mask;
> + unsigned int *mask;
> const char * const *texts;
> const unsigned int *values;
> + enum snd_soc_enum_type type;
> + unsigned int num_regs;
> };
>
> /**
> diff --git a/sound/soc/soc-core.c b/sound/soc/soc-core.c
> index caebd63..cf29722 100644
> --- a/sound/soc/soc-core.c
> +++ b/sound/soc/soc-core.c
> @@ -2601,12 +2601,12 @@ int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
> unsigned int val, item;
> unsigned int reg_val;
>
> - reg_val = snd_soc_read(codec, e->reg);
> - val = (reg_val >> e->shift_l) & e->mask;
> + reg_val = snd_soc_read(codec, e->reg[0]);
> + val = (reg_val >> e->shift_l) & e->mask[0];
> item = snd_soc_enum_val_to_item(e, val);
> ucontrol->value.enumerated.item[0] = item;
> if (e->shift_l != e->shift_r) {
> - val = (reg_val >> e->shift_l) & e->mask;
> + val = (reg_val >> e->shift_l) & e->mask[0];
> item = snd_soc_enum_val_to_item(e, val);
> ucontrol->value.enumerated.item[1] = item;
> }
> @@ -2636,15 +2636,15 @@ int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
> if (item[0] >= e->items)
> return -EINVAL;
> val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
> - mask = e->mask << e->shift_l;
> + mask = e->mask[0] << e->shift_l;
> if (e->shift_l != e->shift_r) {
> if (item[1] >= e->items)
> return -EINVAL;
> val |= snd_soc_enum_item_to_val(e, item[1]) << e->shift_r;
> - mask |= e->mask << e->shift_r;
> + mask |= e->mask[0] << e->shift_r;
> }
>
> - return snd_soc_update_bits_locked(codec, e->reg, mask, val);
> + return snd_soc_update_bits_locked(codec, e->reg[0], mask, val);
> }
> EXPORT_SYMBOL_GPL(snd_soc_put_enum_double);
>
> diff --git a/sound/soc/soc-dapm.c b/sound/soc/soc-dapm.c
> index c8a780d..19b004a 100644
> --- a/sound/soc/soc-dapm.c
> +++ b/sound/soc/soc-dapm.c
> @@ -511,13 +511,26 @@ static int dapm_connect_mux(struct snd_soc_dapm_context *dapm,
> const struct snd_kcontrol_new *kcontrol)
> {
> struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
> - unsigned int val, item;
> + unsigned int val, item, bit_pos = -1;
> int i;
>
> - if (e->reg != SND_SOC_NOPM) {
> - soc_widget_read(dest, e->reg, &val);
> - val = (val >> e->shift_l) & e->mask;
> - item = snd_soc_enum_val_to_item(e, val);
> + if (e->reg[0] != SND_SOC_NOPM) {
> + if (e->type == SND_SOC_ENUM_ONEHOT) {
> + for (i = 0; i < e->num_regs; i++) {
> + soc_widget_read(dest, e->reg[i], &val);
> + val = val & e->mask[i];
> + if (val != 0) {
> + bit_pos = __ffs(val) +
> + (8 * dest->codec->val_bytes * i);
> + break;
> + }
> + }
> + item = snd_soc_enum_val_to_item(e, bit_pos);
> + } else {
> + soc_widget_read(dest, e->reg[0], &val);
> + val = (val >> e->shift_l) & e->mask[0];
> + item = snd_soc_enum_val_to_item(e, val);
> + }
> } else {
> /* since a virtual mux has no backing registers to
> * decide which path to connect, it will try to match
> @@ -1553,8 +1566,8 @@ static void dapm_widget_update(struct snd_soc_card *card)
> struct snd_soc_dapm_update *update = card->update;
> struct snd_soc_dapm_widget_list *wlist;
> struct snd_soc_dapm_widget *w = NULL;
> - unsigned int wi;
> - int ret;
> + unsigned int wi, i;
> + int ret = 0;
>
> if (!update || !dapm_kcontrol_is_powered(update->kcontrol))
> return;
> @@ -1575,8 +1588,12 @@ static void dapm_widget_update(struct snd_soc_card *card)
> if (!w)
> return;
>
> - ret = soc_widget_update_bits_locked(w, update->reg, update->mask,
> - update->val);
> + /* dapm update for multiple registers */
> + for (i = 0; i < update->num_regs; i++) {
> + ret |= soc_widget_update_bits_locked(w, update->reg[i],
> + update->mask[i], update->val[i]);
> + }
> +
> if (ret < 0)
> dev_err(w->dapm->dev, "ASoC: %s DAPM update failed: %d\n",
> w->name, ret);
> @@ -2866,10 +2883,10 @@ int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
> if (change) {
> if (reg != SND_SOC_NOPM) {
> update.kcontrol = kcontrol;
> - update.reg = reg;
> - update.mask = mask;
> - update.val = val;
> -
> + update.reg[0] = reg;
> + update.mask[0] = mask;
> + update.val[0] = val;
> + update.num_regs = 1;
> card->update = &update;
> }
>
> @@ -2903,15 +2920,15 @@ int snd_soc_dapm_get_enum_double(struct snd_kcontrol *kcontrol,
> struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
> unsigned int reg_val, val;
>
> - if (e->reg != SND_SOC_NOPM)
> - reg_val = snd_soc_read(codec, e->reg);
> + if (e->reg[0] != SND_SOC_NOPM)
> + reg_val = snd_soc_read(codec, e->reg[0]);
> else
> reg_val = dapm_kcontrol_get_value(kcontrol);
>
> - val = (reg_val >> e->shift_l) & e->mask;
> + val = (reg_val >> e->shift_l) & e->mask[0];
> ucontrol->value.enumerated.item[0] = snd_soc_enum_val_to_item(e, val);
> if (e->shift_l != e->shift_r) {
> - val = (reg_val >> e->shift_r) & e->mask;
> + val = (reg_val >> e->shift_r) & e->mask[0];
> val = snd_soc_enum_val_to_item(e, val);
> ucontrol->value.enumerated.item[1] = val;
> }
> @@ -2945,27 +2962,28 @@ int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
> return -EINVAL;
>
> val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
> - mask = e->mask << e->shift_l;
> + mask = e->mask[0] << e->shift_l;
> if (e->shift_l != e->shift_r) {
> if (item[1] > e->items)
> return -EINVAL;
> val |= snd_soc_enum_item_to_val(e, item[1]) << e->shift_l;
> - mask |= e->mask << e->shift_r;
> + mask |= e->mask[0] << e->shift_r;
> }
>
> mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
>
> - if (e->reg != SND_SOC_NOPM)
> - change = snd_soc_test_bits(codec, e->reg, mask, val);
> + if (e->reg[0] != SND_SOC_NOPM)
> + change = snd_soc_test_bits(codec, e->reg[0], mask, val);
> else
> change = dapm_kcontrol_set_value(kcontrol, val);
>
> if (change) {
> - if (e->reg != SND_SOC_NOPM) {
> + if (e->reg[0] != SND_SOC_NOPM) {
> update.kcontrol = kcontrol;
> - update.reg = e->reg;
> - update.mask = mask;
> - update.val = val;
> + update.reg[0] = e->reg[0];
> + update.mask[0] = mask;
> + update.val[0] = val;
> + update.num_regs = 1;
> card->update = &update;
> }
>
> @@ -2984,6 +3002,112 @@ int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
> EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double);
>
> /**
> + * snd_soc_dapm_get_enum_onehot - dapm enumerated onehot mixer get callback
> + * @kcontrol: mixer control
> + * @ucontrol: control element information
> + *
> + * Callback to get the value of a dapm enumerated onehot encoded mixer control
> + *
> + * Returns 0 for success.
> + */
> +int snd_soc_dapm_get_enum_onehot(struct snd_kcontrol *kcontrol,
> + struct snd_ctl_elem_value *ucontrol)
> +{
> + struct snd_soc_codec *codec = snd_soc_dapm_kcontrol_codec(kcontrol);
> + struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
> + unsigned int reg_val, val, bit_pos = -1, reg_idx;
> +
> + for (reg_idx = 0; reg_idx < e->num_regs; reg_idx++) {
> + reg_val = snd_soc_read(codec, e->reg[reg_idx]);
> + val = reg_val & e->mask[reg_idx];
> + if (val != 0) {
> + bit_pos = __ffs(val) + (8 * codec->val_bytes * reg_idx);
> + break;
> + }
> + }
> +
> + ucontrol->value.enumerated.item[0] =
> + snd_soc_enum_val_to_item(e, bit_pos);
> +
> + return 0;
> +}
> +EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_onehot);
> +
> +/**
> + * snd_soc_dapm_put_enum_onehot - dapm enumerated onehot mixer put callback
> + * @kcontrol: mixer control
> + * @ucontrol: control element information
> + *
> + * Callback to put the value of a dapm enumerated onehot encoded mixer control
> + *
> + * Returns 0 for success.
> + */
> +int snd_soc_dapm_put_enum_onehot(struct snd_kcontrol *kcontrol,
> + struct snd_ctl_elem_value *ucontrol)
> +{
> + struct snd_soc_codec *codec = snd_soc_dapm_kcontrol_codec(kcontrol);
> + struct snd_soc_card *card = codec->card;
> + struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
> + unsigned int *item = ucontrol->value.enumerated.item;
> + unsigned int change = 0, reg_idx = 0, value, bit_pos;
> + struct snd_soc_dapm_update update;
> + int ret = 0, reg_val = 0, i, update_idx = 0;
> +
> + if (item[0] >= e->items)
> + return -EINVAL;
> +
> + value = snd_soc_enum_item_to_val(e, item[0]);
> +
> + if (value >= 0) {
> + /* get the register index and value to set */
> + reg_idx = value / (8 * codec->val_bytes);
> + bit_pos = value % (8 * codec->val_bytes);
> + reg_val = BIT(bit_pos);
> + }
> +
> + for (i = 0; i < e->num_regs; i++) {
> + if (i == reg_idx) {
> + change = snd_soc_test_bits(codec, e->reg[i],
> + e->mask[i], reg_val);
> + /* set the selected register */
> + update.reg[e->num_regs - 1] = e->reg[reg_idx];
> + update.mask[e->num_regs - 1] = e->mask[reg_idx];
> + update.val[e->num_regs - 1] = reg_val;
> + } else {
> + /* accumulate the change to update the DAPM path
> + when none is selected */
> + change |= snd_soc_test_bits(codec, e->reg[i],
> + e->mask[i], 0);
> +
> + /* clear the register when not selected */
> + update.reg[update_idx] = e->reg[i];
> + update.mask[update_idx] = e->mask[i];
> + update.val[update_idx++] = 0;
> + }
> + }
> +
> + mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
> +
> + if (change) {
> + update.kcontrol = kcontrol;
> + update.num_regs = 3;
> + card->update = &update;
> +
> + ret = soc_dapm_mux_update_power(card, kcontrol, item[0], e);
> +
> + card->update = NULL;
> + }
> +
> + mutex_unlock(&card->dapm_mutex);
> +
> + if (ret > 0)
> + soc_dpcm_runtime_update(card);
> +
> + return change;
> +}
> +EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_onehot);
> +
> +/**
> * snd_soc_dapm_info_pin_switch - Info for a pin switch
> *
> * @kcontrol: mixer control
> --
> 1.7.9.5
>