ASoC: hdac_hdmi: Enable playback on all enumerated ports

Last patch added infrastructure to render over all the ports,
PCM<->cvt<- pin mapping and user selection of controls. But we
still have restriction of playback on the default port alone, so
remove that.

This patch removes the hardcoding of cvt<->pin map from the dai.
Cvt and pin for a dai are now derived from the already stored pcm
list of device opened.  We query connection list of a pin from
codec to validate the cvt<->pin map.

If connection list returns zero, then monitor is not connected so
fail playback.

Signed-off-by: Subhransu S. Prusty <subhransu.s.prusty@intel.com>
Signed-off-by: Jeeja KP <jeeja.kp@intel.com>
Signed-off-by: Vinod Koul <vinod.koul@intel.com>
Signed-off-by: Mark Brown <broonie@kernel.org>

1 files changed, 132 insertions, 42 deletions

diff --git a/sound/soc/codecs/hdac_hdmi.c b/sound/soc/codecs/hdac_hdmi.c
index 839148688744..dcd1cb643145 100644
--- a/sound/soc/codecs/hdac_hdmi.c
+++ b/sound/soc/codecs/hdac_hdmi.c
@@ -40,6 +40,8 @@
 
 #define HDA_MAX_CONNECTIONS     32
 
+#define HDA_MAX_CVTS            3
+
 #define ELD_MAX_SIZE    256
 #define ELD_FIXED_BYTES 20
 
@@ -91,7 +93,7 @@ struct hdac_hdmi_dai_pin_map {
 };
 
 struct hdac_hdmi_priv {
-        struct hdac_hdmi_dai_pin_map dai_map[3];
+        struct hdac_hdmi_dai_pin_map dai_map[HDA_MAX_CVTS];
         struct list_head pin_list;
         struct list_head cvt_list;
         struct list_head pcm_list;
@@ -384,44 +386,136 @@ static int hdac_hdmi_playback_cleanup(struct snd_pcm_substream *substream,
         return 0;
 }
 
+static int hdac_hdmi_enable_pin(struct hdac_ext_device *hdac,
+                struct hdac_hdmi_dai_pin_map *dai_map)
+{
+        int mux_idx;
+        struct hdac_hdmi_pin *pin = dai_map->pin;
+
+        for (mux_idx = 0; mux_idx < pin->num_mux_nids; mux_idx++) {
+                if (pin->mux_nids[mux_idx] == dai_map->cvt->nid) {
+                        snd_hdac_codec_write(&hdac->hdac, pin->nid, 0,
+                                        AC_VERB_SET_CONNECT_SEL, mux_idx);
+                        break;
+                }
+        }
+
+        if (mux_idx == pin->num_mux_nids)
+                return -EIO;
+
+        /* Enable out path for this pin widget */
+        snd_hdac_codec_write(&hdac->hdac, pin->nid, 0,
+                        AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
+
+        hdac_hdmi_set_power_state(hdac, dai_map, AC_PWRST_D0);
+
+        snd_hdac_codec_write(&hdac->hdac, pin->nid, 0,
+                        AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
+
+        return 0;
+}
+
+static int hdac_hdmi_query_pin_connlist(struct hdac_ext_device *hdac,
+                                        struct hdac_hdmi_pin *pin)
+{
+        if (!(get_wcaps(&hdac->hdac, pin->nid) & AC_WCAP_CONN_LIST)) {
+                dev_warn(&hdac->hdac.dev,
+                        "HDMI: pin %d wcaps %#x does not support connection list\n",
+                        pin->nid, get_wcaps(&hdac->hdac, pin->nid));
+                return -EINVAL;
+        }
+
+        pin->num_mux_nids = snd_hdac_get_connections(&hdac->hdac, pin->nid,
+                        pin->mux_nids, HDA_MAX_CONNECTIONS);
+        if (pin->num_mux_nids == 0)
+                dev_warn(&hdac->hdac.dev, "No connections found for pin: %d\n",
+                                                                pin->nid);
+
+        dev_dbg(&hdac->hdac.dev, "num_mux_nids %d for pin: %d\n",
+                        pin->num_mux_nids, pin->nid);
+
+        return pin->num_mux_nids;
+}
+
+/*
+ * Query pcm list and return pin widget to which stream is routed.
+ *
+ * Also query connection list of the pin, to validate the cvt to pin map.
+ *
+ * Same stream rendering to multiple pins simultaneously can be done
+ * possibly, but not supported for now in driver. So return the first pin
+ * connected.
+ */
+static struct hdac_hdmi_pin *hdac_hdmi_get_pin_from_cvt(
+                        struct hdac_ext_device *edev,
+                        struct hdac_hdmi_priv *hdmi,
+                        struct hdac_hdmi_cvt *cvt)
+{
+        struct hdac_hdmi_pcm *pcm;
+        struct hdac_hdmi_pin *pin = NULL;
+        int ret, i;
+
+        list_for_each_entry(pcm, &hdmi->pcm_list, head) {
+                if (pcm->cvt == cvt) {
+                        pin = pcm->pin;
+                        break;
+                }
+        }
+
+        if (pin) {
+                ret = hdac_hdmi_query_pin_connlist(edev, pin);
+                if (ret < 0)
+                        return NULL;
+
+                for (i = 0; i < pin->num_mux_nids; i++) {
+                        if (pin->mux_nids[i] == cvt->nid)
+                                return pin;
+                }
+        }
+
+        return NULL;
+}
+
 static int hdac_hdmi_pcm_open(struct snd_pcm_substream *substream,
                         struct snd_soc_dai *dai)
 {
         struct hdac_ext_device *hdac = snd_soc_dai_get_drvdata(dai);
         struct hdac_hdmi_priv *hdmi = hdac->private_data;
         struct hdac_hdmi_dai_pin_map *dai_map;
+        struct hdac_hdmi_cvt *cvt;
+        struct hdac_hdmi_pin *pin;
         int ret;
 
-        if (dai->id > 0) {
-                dev_err(&hdac->hdac.dev, "Only one dai supported as of now\n");
-                return -ENODEV;
-        }
-
         dai_map = &hdmi->dai_map[dai->id];
 
-        if ((!dai_map->pin->eld.monitor_present) ||
-                        (!dai_map->pin->eld.eld_valid)) {
+        cvt = dai_map->cvt;
+        pin = hdac_hdmi_get_pin_from_cvt(hdac, hdmi, cvt);
+        if (!pin)
+                return -EIO;
+
+        if ((!pin->eld.monitor_present) ||
+                        (!pin->eld.eld_valid)) {
 
                 dev_err(&hdac->hdac.dev,
-                                "Failed: montior present? %d ELD valid?: %d\n",
-                                dai_map->pin->eld.monitor_present,
-                                dai_map->pin->eld.eld_valid);
+                        "Failed: montior present? %d ELD valid?: %d for pin: %d\n",
+                        pin->eld.monitor_present, pin->eld.eld_valid, pin->nid);
 
                 return -ENODEV;
         }
 
-        hdac_hdmi_set_power_state(hdac, dai_map, AC_PWRST_D0);
+        dai_map->pin = pin;
 
-        snd_hdac_codec_write(&hdac->hdac, dai_map->pin->nid, 0,
-                        AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
+        ret = hdac_hdmi_enable_pin(hdac, dai_map);
+        if (ret < 0)
+                return ret;
 
         ret = hdac_hdmi_eld_limit_formats(substream->runtime,
-                                dai_map->pin->eld.eld_buffer);
+                                pin->eld.eld_buffer);
         if (ret < 0)
                 return ret;
 
         return snd_pcm_hw_constraint_eld(substream->runtime,
-                                dai_map->pin->eld.eld_buffer);
+                                pin->eld.eld_buffer);
 }
 
 static void hdac_hdmi_pcm_close(struct snd_pcm_substream *substream,
@@ -437,6 +531,8 @@ static void hdac_hdmi_pcm_close(struct snd_pcm_substream *substream,
 
         snd_hdac_codec_write(&hdac->hdac, dai_map->pin->nid, 0,
                         AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
+
+        dai_map->pin = NULL;
 }
 
 static int
@@ -759,40 +855,34 @@ static int create_fill_widget_route_map(struct snd_soc_dapm_context *dapm)
 static int hdac_hdmi_init_dai_map(struct hdac_ext_device *edev)
 {
         struct hdac_hdmi_priv *hdmi = edev->private_data;
-        struct hdac_hdmi_dai_pin_map *dai_map = &hdmi->dai_map[0];
+        struct hdac_hdmi_dai_pin_map *dai_map;
         struct hdac_hdmi_cvt *cvt;
-        struct hdac_hdmi_pin *pin;
+        int dai_id = 0;
 
-        if (list_empty(&hdmi->cvt_list) || list_empty(&hdmi->pin_list))
+        if (list_empty(&hdmi->cvt_list))
                 return -EINVAL;
 
-        /*
-         * Currently on board only 1 pin and 1 converter is enabled for
-         * simplification, more will be added eventually
-         * So using fixed map for dai_id:pin:cvt
-         */
-        cvt = list_first_entry(&hdmi->cvt_list, struct hdac_hdmi_cvt, head);
-        pin = list_first_entry(&hdmi->pin_list, struct hdac_hdmi_pin, head);
-
-        dai_map->dai_id = 0;
-        dai_map->pin = pin;
+        list_for_each_entry(cvt, &hdmi->cvt_list, head) {
+                dai_map = &hdmi->dai_map[dai_id];
+                dai_map->dai_id = dai_id;
+                dai_map->cvt = cvt;
 
-        dai_map->cvt = cvt;
+                /* Enable transmission */
+                snd_hdac_codec_write(&edev->hdac, cvt->nid, 0,
+                                AC_VERB_SET_DIGI_CONVERT_1, 1);
 
-        /* Enable out path for this pin widget */
-        snd_hdac_codec_write(&edev->hdac, pin->nid, 0,
-                        AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
+                /* Category Code (CC) to zero */
+                snd_hdac_codec_write(&edev->hdac, cvt->nid, 0,
+                                AC_VERB_SET_DIGI_CONVERT_2, 0);
 
-        /* Enable transmission */
-        snd_hdac_codec_write(&edev->hdac, cvt->nid, 0,
-                        AC_VERB_SET_DIGI_CONVERT_1, 1);
+                dai_id++;
 
-        /* Category Code (CC) to zero */
-        snd_hdac_codec_write(&edev->hdac, cvt->nid, 0,
-                        AC_VERB_SET_DIGI_CONVERT_2, 0);
-
-        snd_hdac_codec_write(&edev->hdac, pin->nid, 0,
-                        AC_VERB_SET_CONNECT_SEL, 0);
+                if (dai_id == HDA_MAX_CVTS) {
+                        dev_warn(&edev->hdac.dev,
+                                "Max dais supported: %d\n", dai_id);
+                        break;
+                }
+        }
 
         return 0;
 }