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>

diff --git a/sound/soc/codecs/hdac_hdmi.c b/sound/soc/codecs/hdac_hdmi.c
index 83914868874490cc944e488139e289ec8ff7b634..dcd1cb64314583d0598d071dfd7b39e80f3d8a7f 100644 (file)
--- 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;
 }