Signed-off-by: Subhransu S. Prusty subhransu.s.prusty@intel.com Signed-off-by: Vinod Koul vinod.koul@intel.com --- sound/hda/local.h | 10 ++++++++++ 1 file changed, 10 insertions(+)

diff --git a/sound/hda/local.h b/sound/hda/local.h index 0d5bb15..a51f5f6 100644 --- a/sound/hda/local.h +++ b/sound/hda/local.h @@ -8,6 +8,16 @@ #define get_wcaps(codec, nid) \ snd_hdac_read_parm(codec, nid, AC_PAR_AUDIO_WIDGET_CAP)

+#define get_pcaps(codec, nid) \ + snd_hdac_read_parm(codec, nid, AC_PAR_PIN_CAP) + +static inline int is_input_pin(struct hdac_device *codec, hda_nid_t nid) +{ + unsigned int pincap = get_pcaps(codec, nid); + + return (pincap & AC_PINCAP_IN) != 0; +} + /* get the widget type from widget capability bits */ static inline int get_wcaps_type(unsigned int wcaps) {

HDA device widgets are mapped to dapm widgets to take advantage of DAPM. Each HDA widget can be mapped to one or multiple dapm widgets based on interface and how it is connected with other widgets.

For example, a PIN widget 2 or 3 dapm widgets are created depending on the capability. A dapm input/out widget is created to represent the input/output capability, a pga widget is created so that pin with retasking capability can be properly represented in a dapm graph and a mux widget for output pin is created, if the connection list has more than one input.

Signed-off-by: Subhransu S. Prusty subhransu.s.prusty@intel.com Signed-off-by: Vinod Koul vinod.koul@intel.com --- sound/soc/codecs/hdac_generic.c | 478 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 477 insertions(+), 1 deletion(-)

diff --git a/sound/soc/codecs/hdac_generic.c b/sound/soc/codecs/hdac_generic.c index 99e624e..7f3a2a0 100644 --- a/sound/soc/codecs/hdac_generic.c +++ b/sound/soc/codecs/hdac_generic.c @@ -43,6 +43,16 @@ struct hdac_generic_priv { unsigned int num_dapm_widgets; };

+/* + * Widgets types can be accessed using an array with an index except vendor + * types. So fill NULL for the invalid indexes. + */ +static char *wid_names[] = { + "dac", "adc", "mixer", "mux", "pin", "power", + "volme knob", "beep", NULL, NULL, NULL, NULL, + NULL, NULL, NULL, "vendor", +}; + static void hdac_generic_set_power_state(struct hdac_ext_device *edev, hda_nid_t nid, unsigned int pwr_state) { @@ -52,6 +62,467 @@ static void hdac_generic_set_power_state(struct hdac_ext_device *edev, AC_VERB_SET_POWER_STATE, pwr_state); }

+static int hdac_generic_fill_widget_info(struct device *dev, + struct snd_soc_dapm_widget *w, enum snd_soc_dapm_type id, + void *priv, const char *wname, const char *stream, + struct snd_kcontrol_new *wc, int numkc, + int (*event)(struct snd_soc_dapm_widget *, + struct snd_kcontrol *, int), unsigned short event_flags) +{ + w->id = id; + w->name = devm_kstrdup(dev, wname, GFP_KERNEL); + if (!w->name) + return -ENOMEM; + + w->sname = stream; + w->reg = SND_SOC_NOPM; + w->shift = 0; + w->kcontrol_news = wc; + w->num_kcontrols = numkc; + w->priv = priv; + w->event = event; + w->event_flags = event_flags; + + return 0; +} + +static int hdac_generic_alloc_mux_widget(struct snd_soc_dapm_context *dapm, + struct snd_soc_dapm_widget *widgets, int index, + struct hdac_codec_widget *wid) + +{ + struct snd_kcontrol_new *kc; + struct soc_enum *se; + char kc_name[HDAC_GENERIC_NAME_SIZE]; + char mux_items[HDAC_GENERIC_NAME_SIZE]; + char widget_name[HDAC_GENERIC_NAME_SIZE]; + const char *name; + /* To hold inputs to the Pin mux */ + char *items[HDA_MAX_CONNECTIONS]; + int i = 0, ret; + int num_items = wid->num_inputs + 1; + + if (wid->type == AC_WID_AUD_SEL) + sprintf(widget_name, "Mux %x", wid->nid); + else if (wid->type == AC_WID_PIN) + sprintf(widget_name, "Pin %x Mux", wid->nid); + else + return -EINVAL; + + kc = devm_kzalloc(dapm->dev, sizeof(*kc), GFP_KERNEL); + if (!kc) + return -ENOMEM; + + se = devm_kzalloc(dapm->dev, sizeof(*se), GFP_KERNEL); + if (!se) + return -ENOMEM; + + sprintf(kc_name, "Mux %d Input", wid->nid); + kc->name = devm_kstrdup(dapm->dev, kc_name, GFP_KERNEL); + if (!kc->name) + return -ENOMEM; + + kc->private_value = (long)se; + kc->iface = SNDRV_CTL_ELEM_IFACE_MIXER; + kc->access = 0; + kc->info = snd_soc_info_enum_double; + kc->put = snd_soc_dapm_put_enum_double; + kc->get = snd_soc_dapm_get_enum_double; + + se->reg = SND_SOC_NOPM; + + se->items = num_items; + se->mask = roundup_pow_of_two(se->items) - 1; + + sprintf(mux_items, "NONE"); + items[i] = devm_kstrdup(dapm->dev, mux_items, GFP_KERNEL); + if (!items[i]) + return -ENOMEM; + + for (i = 0; i < wid->num_inputs; i++) { + name = wid_names[wid->conn_list[i].type]; + if (!name) + return -EINVAL; + + sprintf(mux_items, "%s %x", name, wid->conn_list[i].nid); + items[i + 1] = devm_kstrdup(dapm->dev, mux_items, GFP_KERNEL); + if (!items[i]) + return -ENOMEM; + } + + se->texts = devm_kmemdup(dapm->dev, items, + (num_items * sizeof(char *)), GFP_KERNEL); + if (!se->texts) + return -ENOMEM; + + ret = hdac_generic_fill_widget_info(dapm->dev, &widgets[index], + snd_soc_dapm_mux, wid, widget_name, NULL, kc, 1, + NULL, 0); + + if (ret < 0) + return ret; + + wid->priv = &widgets[index]; + + return 0; +} + +static const char *get_dai_stream(struct snd_soc_dai_driver *dai_drv, + int num_dais, struct hdac_codec_widget *wid) +{ + int i; + struct hdac_codec_widget *tmp; + + for (i = 0; i < num_dais; i++) { + tmp = dai_drv[i].dobj.private; + if (tmp->nid == wid->nid) { + if (wid->type == AC_WID_AUD_IN) + return dai_drv[i].capture.stream_name; + else + return dai_drv[i].playback.stream_name; + } + } + + return NULL; +} + +static int hdac_codec_alloc_cvt_widget(struct snd_soc_dapm_context *dapm, + struct snd_soc_dapm_widget *widgets, int index, + struct hdac_codec_widget *wid) +{ + struct snd_soc_dai_driver *dai_drv = dapm->component->dai_drv; + char widget_name[HDAC_GENERIC_NAME_SIZE]; + const char *dai_strm_name; + int ret = 0; + + dai_strm_name = get_dai_stream(dai_drv, + dapm->component->num_dai, wid); + if (!dai_strm_name) + return -EINVAL; + + if (wid->type == AC_WID_AUD_IN) { + sprintf(widget_name, "ADC %x", wid->nid); + } else { + sprintf(widget_name, "%s DAC %x", + (wid->caps & AC_WCAP_DIGITAL) ? "Digital" : "Analog", + wid->nid); + } + + ret = hdac_generic_fill_widget_info(dapm->dev, &widgets[index], + wid->type == AC_WID_AUD_IN ? + snd_soc_dapm_aif_in : snd_soc_dapm_aif_out, + wid, widget_name, dai_strm_name, NULL, 0, NULL, 0); + if (ret < 0) + return ret; + + wid->priv = &widgets[index]; + + return 0; +} + +static int hdac_codec_alloc_mixer_widget(struct snd_soc_dapm_context *dapm, + struct snd_soc_dapm_widget *w, int index, + struct hdac_codec_widget *wid) +{ + struct snd_kcontrol_new *kc; + struct soc_mixer_control *mc; + char kc_name[HDAC_GENERIC_NAME_SIZE]; + char widget_name[HDAC_GENERIC_NAME_SIZE]; + const char *name; + int i, ret; + + kc = devm_kcalloc(dapm->dev, wid->num_inputs, sizeof(*kc), GFP_KERNEL); + if (!kc) + return -ENOMEM; + + for (i = 0; i < wid->num_inputs; i++) { + name = wid_names[wid->conn_list[i].type]; + if (!name) + return -EINVAL; + + sprintf(kc_name, "%s %x in Switch", + name, wid->conn_list[i].nid); + kc[i].name = devm_kstrdup(dapm->dev, kc_name, GFP_KERNEL); + if (!kc[i].name) + return -ENOMEM; + + mc = devm_kzalloc(dapm->dev, (sizeof(*mc)), GFP_KERNEL); + if (!mc) + return -ENOMEM; + + mc->reg = SND_SOC_NOPM; + mc->rreg = SND_SOC_NOPM; + mc->max = 1; + + kc[i].private_value = (long)mc; + kc[i].iface = SNDRV_CTL_ELEM_IFACE_MIXER; + kc[i].info = snd_soc_info_volsw; + kc[i].put = snd_soc_dapm_put_volsw; + kc[i].get = snd_soc_dapm_get_volsw; + } + + sprintf(widget_name, "Mixer %x", wid->nid); + ret = hdac_generic_fill_widget_info(dapm->dev, &w[index], + snd_soc_dapm_mixer, wid, widget_name, NULL, + kc, wid->num_inputs, NULL, 0); + if (ret < 0) + return ret; + + wid->priv = &w[index]; + + return 0; +} + +/* + * Each Pin widget will be represented with: + * DAPM input/output - Based on out/in capability queried + * DAPM PGA - To program the PIN configuration + * DAPM Mux - Create a virtual Mux widget, if output capable pin can + * select from multiple inputs. + * + * Returns number of dapm widgets created on success else returns -ve error + * code. + */ +static int hdac_codec_alloc_pin_widget(struct snd_soc_dapm_context *dapm, + struct snd_soc_dapm_widget *widgets, int index, + struct hdac_codec_widget *wid) +{ + struct hdac_ext_device *edev = to_hda_ext_device(dapm->dev); + char widget_name[HDAC_GENERIC_NAME_SIZE]; + int i = index; + int ret; + bool input; + /* + * Pin complex are represented with multiple dapm widgets. Cache them + * for easy reference. wid_ref[0]->input/output, wid_ref[1]->pga, + * wid_ref[2]->mux. + */ + struct snd_soc_dapm_widget **wid_ref; + + input = is_input_pin(&edev->hdac, wid->nid); + + wid_ref = devm_kmalloc_array(dapm->dev, 3, sizeof(wid_ref), GFP_KERNEL); + if (!wid_ref) + return -ENOMEM; + + /* Create output/input widget */ + sprintf(widget_name, "Pin %x %s", wid->nid, + input ? "Input" : "Output"); + + ret = hdac_generic_fill_widget_info(dapm->dev, &widgets[i], + input ? snd_soc_dapm_input : snd_soc_dapm_output, + wid, widget_name, NULL, NULL, 0, NULL, 0); + if (ret < 0) + return ret; + + wid_ref[0] = &widgets[i++]; + + /* Create PGA widget */ + sprintf(widget_name, "Pin %x PGA", wid->nid); + ret = hdac_generic_fill_widget_info(dapm->dev, &widgets[i], + snd_soc_dapm_pga, wid, widget_name, NULL, + NULL, 0, NULL, 0); + if (ret < 0) + return ret; + + wid_ref[1] = &widgets[i++]; + + /* Create Mux if Pin widget can select from multiple inputs */ + if (!input && wid->num_inputs > 1) { + sprintf(widget_name, "Pin %x Mux", wid->nid); + ret = hdac_generic_alloc_mux_widget(dapm, widgets, i, wid); + if (ret < 0) + return ret; + + wid_ref[2] = &widgets[i++]; + } + + /* override hda widget private with dapm widget group */ + wid->priv = wid_ref; + + /* Return number of dapm widgets created */ + return i - index; +} + +static int hdac_codec_alloc_power_widget(struct snd_soc_dapm_context *dapm, + struct snd_soc_dapm_widget *widgets, int index, + struct hdac_codec_widget *wid) +{ + char widget_name[HDAC_GENERIC_NAME_SIZE]; + int ret = 0; + + sprintf(widget_name, "Power %x", wid->nid); + ret = hdac_generic_fill_widget_info(dapm->dev, &widgets[index], + snd_soc_dapm_supply, wid, widget_name, + NULL, NULL, 0, NULL, 0); + if (ret < 0) + return ret; + + wid->priv = &widgets[index]; + + return 0; +} + +/* + * Each Beep hda widget will be represented with two dapm widget a siggen + * and a PGA. A virtual switch control will be added to turn on/off DAPM. + */ +static int hdac_codec_alloc_beep_widget(struct snd_soc_dapm_context *dapm, + struct snd_soc_dapm_widget *widgets, int index, + struct hdac_codec_widget *wid) +{ + char widget_name[HDAC_GENERIC_NAME_SIZE]; + int i = index, ret = 0; + struct soc_mixer_control *mc; + struct snd_kcontrol_new *kc; + char kc_name[HDAC_GENERIC_NAME_SIZE]; + /* + * Beep widgets are represented with multiple dapm widgets. Cache them + * for each reference. wid_ref[0]->siggen, wid_ref[1]->pga. + */ + struct snd_soc_dapm_widget **wid_ref; + + wid_ref = devm_kmalloc_array(dapm->dev, 2, sizeof(wid_ref), GFP_KERNEL); + if (!wid_ref) + return -ENOMEM; + + sprintf(widget_name, "Beep Gen %x", wid->nid); + ret = hdac_generic_fill_widget_info(dapm->dev, &widgets[i++], + snd_soc_dapm_siggen, wid, widget_name, + NULL, NULL, 0, NULL, 0); + if (ret < 0) + return ret; + + kc = devm_kzalloc(dapm->dev, + (sizeof(*kc) * wid->num_inputs), + GFP_KERNEL); + if (!kc) + return -ENOMEM; + + sprintf(kc_name, "%s %x in Switch", wid_names[wid->type], wid->nid); + kc[i].name = devm_kstrdup(dapm->dev, kc_name, GFP_KERNEL); + if (!kc[i].name) + return -ENOMEM; + mc = devm_kzalloc(dapm->dev, (sizeof(*mc)), GFP_KERNEL); + if (!mc) + return -ENOMEM; + + mc->reg = SND_SOC_NOPM; + mc->rreg = SND_SOC_NOPM; + mc->max = 1; + + kc[i].private_value = (long)mc; + kc[i].iface = SNDRV_CTL_ELEM_IFACE_MIXER; + kc[i].info = snd_soc_info_volsw; + kc[i].put = snd_soc_dapm_get_volsw; + kc[i].get = snd_soc_dapm_put_volsw; + + sprintf(widget_name, "Beep Gen %x PGA", wid->nid); + ret = hdac_generic_fill_widget_info(dapm->dev, &widgets[i], + snd_soc_dapm_pga, wid, widget_name, + NULL, kc, 1, NULL, 0); + if (ret < 0) + return ret; + + wid->priv = wid_ref; + + return 0; +} + +/* Create DAPM widgets to represent each codec widget */ +static int hdac_codec_alloc_widgets(struct snd_soc_dapm_context *dapm, + struct snd_soc_dapm_widget *widgets) +{ + struct hdac_ext_device *edev = to_hda_ext_device(dapm->dev); + struct hdac_codec_widget *wid; + int index = 0; + int ret = 0; + + list_for_each_entry(wid, &edev->hdac.widget_list, head) { + switch (wid->type) { + case AC_WID_AUD_IN: + case AC_WID_AUD_OUT: + ret = hdac_codec_alloc_cvt_widget(dapm, widgets, + index, wid); + if (ret < 0) + return ret; + index++; + break; + + case AC_WID_PIN: + ret = hdac_codec_alloc_pin_widget(dapm, widgets, + index, wid); + if (ret < 0) + return ret; + index += ret; + break; + + case AC_WID_AUD_MIX: + ret = hdac_codec_alloc_mixer_widget(dapm, widgets, + index, wid); + if (ret < 0) + return ret; + index++; + break; + + case AC_WID_AUD_SEL: + ret = hdac_generic_alloc_mux_widget(dapm, widgets, + index, wid); + if (ret < 0) + return ret; + index++; + break; + + case AC_WID_POWER: + ret = hdac_codec_alloc_power_widget(dapm, widgets, + index, wid); + if (ret < 0) + return ret; + index++; + break; + + case AC_WID_BEEP: + ret = hdac_codec_alloc_beep_widget(dapm, widgets, + index, wid); + if (ret < 0) + return ret; + index += 2; + break; + + default: + dev_warn(&edev->hdac.dev, + "dapm widget not allocated for type: %d\n", + wid->type); + break; + } + } + + return ret; +} + +static int hdac_generic_create_fill_widget_route_map( + struct snd_soc_dapm_context *dapm) +{ + struct snd_soc_dapm_widget *widgets; + struct hdac_ext_device *edev = to_hda_ext_device(dapm->dev); + struct hdac_generic_priv *hdac_priv = edev->private_data; + + widgets = devm_kzalloc(dapm->dev, + (sizeof(*widgets) * hdac_priv->num_dapm_widgets), + GFP_KERNEL); + if (!widgets) + return -ENOMEM; + + /* Create DAPM widgets */ + hdac_codec_alloc_widgets(dapm, widgets); + + snd_soc_dapm_new_controls(dapm, widgets, hdac_priv->num_dapm_widgets); + + /* TODO: Add each path to dapm graph when enumerated */ + + return 0; +} + static void hdac_generic_calc_dapm_widgets(struct hdac_ext_device *edev) { struct hdac_generic_priv *hdac_priv = edev->private_data; @@ -192,10 +663,15 @@ static int hdac_codec_probe(struct snd_soc_codec *codec) struct hdac_ext_device *edev = snd_soc_codec_get_drvdata(codec); struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(&codec->component); + int ret;

edev->scodec = codec;

- /* TODO: create widget, route and controls */ + /* create widget, route and controls */ + ret = hdac_generic_create_fill_widget_route_map(dapm); + if (ret < 0) + return ret; + /* TODO: jack sense */

/* Imp: Store the card pointer in hda_codec */

Signed-off-by: Subhransu S. Prusty subhransu.s.prusty@intel.com Signed-off-by: Vinod Koul vinod.koul@intel.com --- sound/soc/codecs/hdac_hdmi.c | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/sound/soc/codecs/hdac_hdmi.c b/sound/soc/codecs/hdac_hdmi.c index 4e181b2..7ab63bd 100644 --- a/sound/soc/codecs/hdac_hdmi.c +++ b/sound/soc/codecs/hdac_hdmi.c @@ -31,6 +31,7 @@ #include <sound/pcm_drm_eld.h> #include <sound/hda_chmap.h> #include "../../hda/local.h" +#include "../../hda/ext/hdac_codec.h" #include "hdac_hdmi.h"

#define NAME_SIZE 32 @@ -127,13 +128,6 @@ static struct hdac_hdmi_pcm *get_hdmi_pcm_from_id(struct hdac_hdmi_priv *hdmi, return NULL; }

-static inline struct hdac_ext_device *to_hda_ext_device(struct device *dev) -{ - struct hdac_device *hdac = dev_to_hdac_dev(dev); - - return to_ehdac_device(hdac); -} - static unsigned int sad_format(const u8 *sad) { return ((sad[0] >> 0x3) & 0x1f);

Register the event handlers and program the codec by sending required verbs in the event handlers.

Signed-off-by: Subhransu S. Prusty subhransu.s.prusty@intel.com Signed-off-by: Vinod Koul vinod.koul@intel.com --- sound/soc/codecs/hdac_generic.c | 329 +++++++++++++++++++++++++++++++++++++++- sound/soc/codecs/hdac_generic.h | 3 + 2 files changed, 326 insertions(+), 6 deletions(-)

diff --git a/sound/soc/codecs/hdac_generic.c b/sound/soc/codecs/hdac_generic.c index 6bd7b2b..354e81d 100644 --- a/sound/soc/codecs/hdac_generic.c +++ b/sound/soc/codecs/hdac_generic.c @@ -75,6 +75,305 @@ static void hdac_generic_set_power_state(struct hdac_ext_device *edev, AC_VERB_SET_POWER_STATE, pwr_state); }

+/* TODO: Add feature to program by querying capability */ +static void hdac_generic_set_eapd(struct hdac_ext_device *edev, + hda_nid_t nid, bool enable) +{ + u32 pin_caps = snd_hdac_read_parm_uncached(&edev->hdac, + nid, AC_PAR_PIN_CAP); + + if (pin_caps & AC_PINCAP_EAPD) + snd_hdac_codec_write(&edev->hdac, nid, 0, + AC_VERB_SET_EAPD_BTLENABLE, enable ? 2 : 0); +} + +static int hdac_generic_pin_io_event(struct snd_soc_dapm_widget *w, + struct snd_kcontrol *kc, int event) +{ + struct hdac_ext_device *edev = to_hda_ext_device(w->dapm->dev); + struct hdac_codec_widget *wid = w->priv; + int val; + + dev_dbg(&edev->hdac.dev, "%s: widget: %s event: %x\n", + __func__, w->name, event); + + val = snd_hdac_codec_read(&edev->hdac, wid->nid, 0, + AC_VERB_GET_PIN_WIDGET_CONTROL, 0); + + switch (event) { + case SND_SOC_DAPM_PRE_PMU: + if (w->id == snd_soc_dapm_output) { + /* TODO: program using a eapd widget */ + hdac_generic_set_eapd(edev, wid->nid, true); + val |= AC_PINCTL_OUT_EN; + } else { + + /* TODO: program vref using a mixer control */ + val |= AC_PINCTL_VREF_80; + val |= AC_PINCTL_IN_EN; + } + + break; + + case SND_SOC_DAPM_POST_PMD: + if (w->id == snd_soc_dapm_output) { + /* TODO: program using a eapd widget */ + hdac_generic_set_eapd(edev, wid->nid, false); + val &= ~AC_PINCTL_OUT_EN; + } else { + val &= AC_PINCTL_VREF_HIZ; + val &= ~AC_PINCTL_IN_EN; + } + + break; + + default: + dev_warn(&edev->hdac.dev, "Event %d not handled\n", event); + return 0; + } + + snd_hdac_codec_write(&edev->hdac, wid->nid, 0, + AC_VERB_SET_PIN_WIDGET_CONTROL, val); + + return 0; +} + +static int hdac_generic_pin_mux_event(struct snd_soc_dapm_widget *w, + struct snd_kcontrol *kc, int event) +{ + struct hdac_ext_device *edev = to_hda_ext_device(w->dapm->dev); + struct hdac_codec_widget *wid = w->priv; + int mux_idx; + + dev_dbg(&edev->hdac.dev, "%s: widget: %s event: %x\n", + __func__, w->name, event); + if (!kc) + kc = w->kcontrols[0]; + + mux_idx = dapm_kcontrol_get_value(kc); + if (mux_idx > 0) { + snd_hdac_codec_write(&edev->hdac, wid->nid, 0, + AC_VERB_SET_CONNECT_SEL, (mux_idx - 1)); + } + + return 0; +} + +static int hdac_generic_pin_pga_event(struct snd_soc_dapm_widget *w, + struct snd_kcontrol *kc, int event) +{ + struct hdac_ext_device *edev = to_hda_ext_device(w->dapm->dev); + struct hdac_codec_widget *wid = w->priv; + + dev_dbg(&edev->hdac.dev, "%s: widget: %s event: %x\n", + __func__, w->name, event); + + if (event == SND_SOC_DAPM_POST_PMD) { + hdac_generic_set_power_state(edev, wid->nid, AC_PWRST_D3); + snd_hdac_codec_write(&edev->hdac, wid->nid, 0, + AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); + } else { + hdac_generic_set_power_state(edev, wid->nid, AC_PWRST_D0); + snd_hdac_codec_write(&edev->hdac, wid->nid, 0, + AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); + } + + return 0; +} + +static int hdac_generic_widget_power_event(struct snd_soc_dapm_widget *w, + struct snd_kcontrol *kc, int event) +{ + struct hdac_ext_device *edev = to_hda_ext_device(w->dapm->dev); + struct hdac_codec_widget *wid = w->priv; + + dev_dbg(&edev->hdac.dev, "%s: widget: %s event: %x\n", + __func__, w->name, event); + hdac_generic_set_power_state(edev, wid->nid, + (event == SND_SOC_DAPM_POST_PMD ? AC_PWRST_D3:AC_PWRST_D0)); + + return 0; +} + +static int hdac_generic_cvt_event(struct snd_soc_dapm_widget *w, + struct snd_kcontrol *kc, int event) +{ + struct hdac_ext_device *edev = to_hda_ext_device(w->dapm->dev); + struct hdac_codec_widget *wid = w->priv; + + hdac_generic_widget_power_event(w, kc, event); + + if (event == SND_SOC_DAPM_POST_PMD) + snd_hdac_codec_write(&edev->hdac, wid->nid, 0, + AC_VERB_SET_AMP_GAIN_MUTE, + AMP_IN_MUTE(0)); + else + snd_hdac_codec_write(&edev->hdac, wid->nid, 0, + AC_VERB_SET_AMP_GAIN_MUTE, + AMP_IN_UNMUTE(0) | 0x5b); + + return 0; +} + +static int get_mixer_control_index(struct snd_soc_dapm_widget *w, + struct snd_kcontrol *kc) +{ + int i; + + for (i = 0; i < w->num_kcontrols; i++) { + if (w->kcontrols[i] == kc) + return i; + } + + return -EINVAL; +} + +static int hdac_generic_mixer_event(struct snd_soc_dapm_widget *w, + struct snd_kcontrol *kc, int event) +{ + struct hdac_ext_device *edev = to_hda_ext_device(w->dapm->dev); + struct hdac_codec_widget *wid = w->priv; + bool no_input = true; + int i; + + dev_dbg(&edev->hdac.dev, "%s: widget: %s event: %x\n", + __func__, w->name, event); + + switch (event) { + case SND_SOC_DAPM_PRE_PMU: + hdac_generic_set_power_state(edev, wid->nid, AC_PWRST_D0); + + + snd_hdac_codec_write(&edev->hdac, wid->nid, 0, + AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); + + for (i = 0; i < w->num_kcontrols; i++) { + if (dapm_kcontrol_get_value(w->kcontrols[i])) { + snd_hdac_codec_write(&edev->hdac, wid->nid, 0, + AC_VERB_SET_AMP_GAIN_MUTE, + AMP_IN_UNMUTE(i)); + } + } + + return 0; + + case SND_SOC_DAPM_POST_PMD: + snd_hdac_codec_write(&edev->hdac, wid->nid, 0, + AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); + + for (i = 0; i < w->num_kcontrols; i++) { + if (dapm_kcontrol_get_value(w->kcontrols[i])) { + snd_hdac_codec_write(&edev->hdac, wid->nid, 0, + AC_VERB_SET_AMP_GAIN_MUTE, + AMP_IN_MUTE(i)); + } + } + + hdac_generic_set_power_state(edev, wid->nid, AC_PWRST_D3); + + return 0; + + case SND_SOC_DAPM_POST_REG: + i = get_mixer_control_index(w, kc); + if (i < 0) { + dev_err(&edev->hdac.dev, + "%s: Wrong kcontrol event: %s\n", + __func__, kc->id.name); + return i; + } + if (dapm_kcontrol_get_value(kc)) { + snd_hdac_codec_write(&edev->hdac, wid->nid, 0, + AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(i)); + no_input = false; + } else { + snd_hdac_codec_write(&edev->hdac, wid->nid, 0, + AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(i)); + } + + if (no_input) + snd_hdac_codec_write(&edev->hdac, wid->nid, 0, + AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); + + return 0; + + default: + dev_warn(&edev->hdac.dev, "Event %d not handled\n", event); + return 0; + } + + return 0; +} + +static void update_mux_amp_switch(struct hdac_ext_device *edev, + hda_nid_t nid, struct snd_kcontrol *kc, bool enable) +{ + struct soc_enum *e = (struct soc_enum *)kc->private_value; + int mux_idx, i; + + mux_idx = dapm_kcontrol_get_value(kc); + + if (!enable || !mux_idx) { + for (i = 1; i < (e->items - 1); i++) + snd_hdac_codec_write(&edev->hdac, nid, 0, + AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(i - 1)); + + snd_hdac_codec_write(&edev->hdac, nid, 0, + AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); + } else { + for (i = 1; i < (e->items - 1); i++) { + if (i == mux_idx) + snd_hdac_codec_write(&edev->hdac, nid, 0, + AC_VERB_SET_AMP_GAIN_MUTE, + AMP_IN_UNMUTE(i - 1)); + else + snd_hdac_codec_write(&edev->hdac, nid, 0, + AC_VERB_SET_AMP_GAIN_MUTE, + AMP_IN_MUTE(i - 1)); + } + + snd_hdac_codec_write(&edev->hdac, nid, 0, + AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); + } +} + +static int hdac_generic_selector_event(struct snd_soc_dapm_widget *w, + struct snd_kcontrol *kc, int event) +{ + struct hdac_ext_device *edev = to_hda_ext_device(w->dapm->dev); + struct hdac_codec_widget *wid = w->priv; + + dev_dbg(&edev->hdac.dev, "%s: widget: %s event: %x\n", + __func__, w->name, event); + + switch (event) { + case SND_SOC_DAPM_PRE_PMU: + hdac_generic_set_power_state(edev, wid->nid, AC_PWRST_D0); + snd_hdac_codec_write(&edev->hdac, wid->nid, 0, + AC_VERB_SET_CONNECT_SEL, + (dapm_kcontrol_get_value(w->kcontrols[0]) - 1)); + update_mux_amp_switch(edev, wid->nid, w->kcontrols[0], true); + + return 0; + + case SND_SOC_DAPM_POST_REG: + update_mux_amp_switch(edev, wid->nid, kc, true); + + return 0; + + case SND_SOC_DAPM_POST_PMD: + update_mux_amp_switch(edev, wid->nid, w->kcontrols[0], false); + hdac_generic_set_power_state(edev, wid->nid, AC_PWRST_D3); + + return 0; + + default: + dev_warn(&edev->hdac.dev, "Event %d not handled\n", event); + return 0; + } + + return 0; +} + static bool is_duplicate_route(struct list_head *route_list, const char *sink, const char *control, const char *src) { @@ -480,7 +779,8 @@ static int hdac_generic_alloc_mux_widget(struct snd_soc_dapm_context *dapm,

ret = hdac_generic_fill_widget_info(dapm->dev, &widgets[index], snd_soc_dapm_mux, wid, widget_name, NULL, kc, 1, - NULL, 0); + hdac_generic_selector_event, SND_SOC_DAPM_PRE_PMU | + SND_SOC_DAPM_POST_PMD | SND_SOC_DAPM_POST_REG);

if (ret < 0) return ret; @@ -534,7 +834,9 @@ static int hdac_codec_alloc_cvt_widget(struct snd_soc_dapm_context *dapm, ret = hdac_generic_fill_widget_info(dapm->dev, &widgets[index], wid->type == AC_WID_AUD_IN ? snd_soc_dapm_aif_in : snd_soc_dapm_aif_out, - wid, widget_name, dai_strm_name, NULL, 0, NULL, 0); + wid, widget_name, dai_strm_name, NULL, 0, + hdac_generic_cvt_event, + SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD); if (ret < 0) return ret;

@@ -587,7 +889,9 @@ static int hdac_codec_alloc_mixer_widget(struct snd_soc_dapm_context *dapm, sprintf(widget_name, "Mixer %x", wid->nid); ret = hdac_generic_fill_widget_info(dapm->dev, &w[index], snd_soc_dapm_mixer, wid, widget_name, NULL, - kc, wid->num_inputs, NULL, 0); + kc, wid->num_inputs, hdac_generic_mixer_event, + SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD | + SND_SOC_DAPM_POST_REG); if (ret < 0) return ret;

@@ -634,7 +938,9 @@ static int hdac_codec_alloc_pin_widget(struct snd_soc_dapm_context *dapm,

ret = hdac_generic_fill_widget_info(dapm->dev, &widgets[i], input ? snd_soc_dapm_input : snd_soc_dapm_output, - wid, widget_name, NULL, NULL, 0, NULL, 0); + wid, widget_name, NULL, NULL, 0, + hdac_generic_pin_io_event, + SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD); if (ret < 0) return ret;

@@ -644,7 +950,8 @@ static int hdac_codec_alloc_pin_widget(struct snd_soc_dapm_context *dapm, sprintf(widget_name, "Pin %x PGA", wid->nid); ret = hdac_generic_fill_widget_info(dapm->dev, &widgets[i], snd_soc_dapm_pga, wid, widget_name, NULL, - NULL, 0, NULL, 0); + NULL, 0, hdac_generic_pin_pga_event, + SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD); if (ret < 0) return ret;

@@ -656,6 +963,15 @@ static int hdac_codec_alloc_pin_widget(struct snd_soc_dapm_context *dapm, ret = hdac_generic_alloc_mux_widget(dapm, widgets, i, wid); if (ret < 0) return ret; + /* + * Pin mux will not use generic selector handler, so + * override. Also mux widget create will increment the + * index, so assign the previous widget. + */ + widgets[i].event_flags = SND_SOC_DAPM_PRE_PMU | + SND_SOC_DAPM_POST_PMD | + SND_SOC_DAPM_POST_REG; + widgets[i].event = hdac_generic_pin_mux_event;

wid_ref[2] = &widgets[i++]; } @@ -677,7 +993,8 @@ static int hdac_codec_alloc_power_widget(struct snd_soc_dapm_context *dapm, sprintf(widget_name, "Power %x", wid->nid); ret = hdac_generic_fill_widget_info(dapm->dev, &widgets[index], snd_soc_dapm_supply, wid, widget_name, - NULL, NULL, 0, NULL, 0); + NULL, NULL, 0, hdac_generic_widget_power_event, + SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD); if (ret < 0) return ret;

diff --git a/sound/soc/codecs/hdac_generic.h b/sound/soc/codecs/hdac_generic.h index 5ca713a..a938b50 100644 --- a/sound/soc/codecs/hdac_generic.h +++ b/sound/soc/codecs/hdac_generic.h @@ -21,5 +21,8 @@ #define __HDAC_GENERIC_H__

#define HDAC_GENERIC_NAME_SIZE 32 +#define AMP_OUT_MUTE 0xb080 +#define AMP_OUT_UNMUTE 0xb000 +#define PIN_OUT (AC_PINCTL_OUT_EN)

#endif /* __HDAC_GENERIC_H__ */

The default configuration of pin complex is queried and machine controls are created.

Signed-off-by: Subhransu S. Prusty subhransu.s.prusty@intel.com Signed-off-by: Vinod Koul vinod.koul@intel.com --- sound/soc/codecs/hdac_generic.c | 170 ++++++++++++++++++++++++++++++++++++++++ sound/soc/codecs/hdac_generic.h | 3 + 2 files changed, 173 insertions(+)

diff --git a/sound/soc/codecs/hdac_generic.c b/sound/soc/codecs/hdac_generic.c index 354e81d..6eb0dc2 100644 --- a/sound/soc/codecs/hdac_generic.c +++ b/sound/soc/codecs/hdac_generic.c @@ -708,6 +708,176 @@ static int hdac_generic_fill_widget_info(struct device *dev, return 0; }

+static int hdac_generic_add_machine_control(struct snd_soc_dapm_context *dapm, + enum snd_soc_dapm_type id, const char *name, + struct hdac_codec_widget *wid, int dir) +{ + struct snd_soc_dapm_widget **wid_ref; + struct snd_soc_dapm_widget *dapm_w; + struct snd_soc_dapm_route route; + char widget_name[HDAC_GENERIC_NAME_SIZE]; + int ret; + + dapm_w = devm_kzalloc(dapm->dev, sizeof(*dapm_w), GFP_KERNEL); + if (!dapm_w) + return -ENOMEM; + + sprintf(widget_name, "%s %x", name, wid->nid); + + ret = hdac_generic_fill_widget_info(dapm->dev, dapm_w, + id, NULL, widget_name, + NULL, NULL, 0, NULL, 0); + if (ret < 0) + return ret; + + wid_ref = wid->priv; + + snd_soc_dapm_new_control(dapm, dapm_w); + if (dir == SNDRV_PCM_STREAM_PLAYBACK) { + route.sink = dapm_w->name; + route.control = NULL; + route.source = wid_ref[0]->name; + route.connected = NULL; + } else { + route.sink = wid_ref[0]->name; + route.control = NULL; + route.source = dapm_w->name; + route.connected = NULL; + } + snd_soc_dapm_add_routes(dapm, &route, 1); + snd_soc_dapm_new_widgets(dapm->card); + + return 0; +} + +/** + * hdac_generic_machine_control_init - Add machine widgets and graph + * @dapm: machine dapm context + * @codec: codec object + * + * Reads the default configuration parameters and builds the machine + * controls and graph. + */ +int hdac_generic_machine_control_init(struct snd_soc_dapm_context *dapm, + struct snd_soc_codec *codec) +{ + struct hdac_ext_device *edev = snd_soc_codec_get_drvdata(codec); + struct hdac_codec_widget *wid; + struct snd_soc_dapm_widget **wid_ref; + unsigned int *cfg; + short dev; + int ret; + + list_for_each_entry(wid, &edev->hdac.widget_list, head) { + + dev_dbg(dapm->dev, "For wid: %x type: %d\n", + wid->nid, wid->type); + if (wid->type != AC_WID_PIN) + continue; + + cfg = wid->params; + dev = get_defcfg_device(*cfg); + + if (is_input_pin(&edev->hdac, wid->nid) && + ((dev == AC_JACK_LINE_OUT) || + (dev == AC_JACK_SPEAKER) || + (dev == AC_JACK_DIG_OTHER_OUT) || + (dev == AC_JACK_HP_OUT) || + (dev == AC_JACK_SPDIF_OUT))) { + + dev_warn(dapm->dev, + "Wrong pin and dev configuration, nid: %x\n", + wid->nid); + + continue; + } + + switch (dev) { + case AC_JACK_LINE_OUT: + ret = hdac_generic_add_machine_control(dapm, + snd_soc_dapm_line, "Lineout", + wid, SNDRV_PCM_STREAM_PLAYBACK); + if (ret < 0) + return ret; + break; + case AC_JACK_SPEAKER: + ret = hdac_generic_add_machine_control(dapm, + snd_soc_dapm_spk, "spk", + wid, SNDRV_PCM_STREAM_PLAYBACK); + if (ret < 0) + return ret; + break; + case AC_JACK_SPDIF_OUT: + ret = hdac_generic_add_machine_control(dapm, + snd_soc_dapm_spk, "spdif_out", + wid, SNDRV_PCM_STREAM_PLAYBACK); + if (ret < 0) + return ret; + break; + case AC_JACK_DIG_OTHER_OUT: + ret = hdac_generic_add_machine_control(dapm, + snd_soc_dapm_spk, "dig_other_out", + wid, SNDRV_PCM_STREAM_PLAYBACK); + if (ret < 0) + return ret; + break; + + case AC_JACK_HP_OUT: + ret = hdac_generic_add_machine_control(dapm, + snd_soc_dapm_hp, "hp", + wid, SNDRV_PCM_STREAM_PLAYBACK); + if (ret < 0) + return ret; + break; + + case AC_JACK_AUX: + ret = hdac_generic_add_machine_control(dapm, + snd_soc_dapm_line, "Aux", + wid, SNDRV_PCM_STREAM_CAPTURE); + if (ret < 0) + return ret; + break; + case AC_JACK_LINE_IN: + ret = hdac_generic_add_machine_control(dapm, + snd_soc_dapm_line, "Linein", + wid, SNDRV_PCM_STREAM_CAPTURE); + if (ret < 0) + return ret; + break; + + case AC_JACK_MIC_IN: + ret = hdac_generic_add_machine_control(dapm, + snd_soc_dapm_mic, "MIC", + wid, SNDRV_PCM_STREAM_CAPTURE); + if (ret < 0) + return ret; + break; + case AC_JACK_SPDIF_IN: + ret = hdac_generic_add_machine_control(dapm, + snd_soc_dapm_mic, "spdif_in", + wid, SNDRV_PCM_STREAM_CAPTURE); + if (ret < 0) + return ret; + break; + case AC_JACK_DIG_OTHER_IN: + ret = hdac_generic_add_machine_control(dapm, + snd_soc_dapm_mic, "dig_other_in", + wid, SNDRV_PCM_STREAM_CAPTURE); + if (ret < 0) + return ret; + break; + + default: + wid_ref = wid->priv; + snd_soc_dapm_nc_pin(dapm, wid_ref[0]->name); + break; + } + } + + return 0; +} +EXPORT_SYMBOL_GPL(hdac_generic_machine_control_init); + static int hdac_generic_alloc_mux_widget(struct snd_soc_dapm_context *dapm, struct snd_soc_dapm_widget *widgets, int index, struct hdac_codec_widget *wid) diff --git a/sound/soc/codecs/hdac_generic.h b/sound/soc/codecs/hdac_generic.h index a938b50..36eafbd 100644 --- a/sound/soc/codecs/hdac_generic.h +++ b/sound/soc/codecs/hdac_generic.h @@ -25,4 +25,7 @@ #define AMP_OUT_UNMUTE 0xb000 #define PIN_OUT (AC_PINCTL_OUT_EN)

+int hdac_generic_machine_control_init(struct snd_soc_dapm_context *dapm, + struct snd_soc_codec *codec); + #endif /* __HDAC_GENERIC_H__ */

Signed-off-by: Subhransu S. Prusty subhransu.s.prusty@intel.com Signed-off-by: Vinod Koul vinod.koul@intel.com --- sound/soc/codecs/hdac_generic.c | 39 ++++++++++++++++++++++++++++++++------- sound/soc/codecs/hdac_generic.h | 5 +++++ 2 files changed, 37 insertions(+), 7 deletions(-)

diff --git a/sound/soc/codecs/hdac_generic.c b/sound/soc/codecs/hdac_generic.c index 6eb0dc2..cf556ee 100644 --- a/sound/soc/codecs/hdac_generic.c +++ b/sound/soc/codecs/hdac_generic.c @@ -41,6 +41,7 @@ struct hdac_generic_priv { unsigned int num_adcs; unsigned int num_dacs; unsigned int num_dapm_widgets; + struct hdac_generic_vendor_ops *vendor_ops; };

/* @@ -1636,6 +1637,7 @@ static int hdac_generic_dev_probe(struct hdac_ext_device *edev) struct hdac_device *codec = &edev->hdac; struct hdac_generic_priv *hdac_priv; struct snd_soc_dai_driver *codec_dais = NULL; + struct hdac_generic_vendor_ops *ops; int num_dais = 0; int ret = 0;

@@ -1676,6 +1678,16 @@ static int hdac_generic_dev_probe(struct hdac_ext_device *edev) return ret; }

+ /* codec specific init if any */ + ops = (struct hdac_generic_vendor_ops *)edev->id_entry->driver_data; + if (ops && ops->init) { + ret = ops->init(edev); + if (ret < 0) + return ret; + } + + hdac_priv->vendor_ops = ops; + /* ASoC specific initialization */ return snd_soc_register_codec(&codec->dev, &hdac_generic_codec, codec_dais, num_dais); @@ -1687,14 +1699,27 @@ static int hdac_generic_dev_remove(struct hdac_ext_device *edev) return 0; }

-/* - * TODO: - * Driver_data will be used to perform any vendor specific init, register - * specific dai ops. - * Driver will implement it's own match function to retrieve driver data. - */ +static void write_def_coeffs(struct hdac_ext_device *edev) +{ + snd_hdac_codec_write(&edev->hdac, 0x20, 0, + AC_VERB_SET_COEF_INDEX, 0x4f); + snd_hdac_codec_write(&edev->hdac, 0x20, 0, + AC_VERB_SET_PROC_COEF, 0x5000); +} + +int hdac_realtek_init(struct hdac_ext_device *edev) +{ + write_def_coeffs(edev); + + return 0; +} + +struct hdac_generic_vendor_ops realtek_ops = { + .init = hdac_realtek_init, +}; + static const struct hda_device_id codec_list[] = { - HDA_CODEC_EXT_ENTRY(0x10ec0286, 0x100002, "ALC286", 0), + HDA_CODEC_EXT_ENTRY(0x10ec0286, 0x100002, "ALC286", &realtek_ops), {} }; MODULE_DEVICE_TABLE(hdaudio, codec_list); diff --git a/sound/soc/codecs/hdac_generic.h b/sound/soc/codecs/hdac_generic.h index 36eafbd..e7cd2e2 100644 --- a/sound/soc/codecs/hdac_generic.h +++ b/sound/soc/codecs/hdac_generic.h @@ -25,6 +25,11 @@ #define AMP_OUT_UNMUTE 0xb000 #define PIN_OUT (AC_PINCTL_OUT_EN)

+struct hdac_generic_vendor_ops { + int (*init)(struct hdac_ext_device *edev); + int (*cleanup)(struct hdac_ext_device *edev); +}; + int hdac_generic_machine_control_init(struct snd_soc_dapm_context *dapm, struct snd_soc_codec *codec);