ASoC: hdac_hdmi: Enable playback on all enumerated ports (148569fd) · Commits · e / devices / android_kernel_fairphone_FP3

sound/soc/codecs/hdac_hdmi.c

+132 −42

Original line number	Original line	Diff line number	Diff line
	@@ -40,6 +40,8 @@

	#define HDA_MAX_CONNECTIONS 32		#define HDA_MAX_CONNECTIONS 32

			#define HDA_MAX_CVTS 3

	#define ELD_MAX_SIZE 256		#define ELD_MAX_SIZE 256
	#define ELD_FIXED_BYTES 20		#define ELD_FIXED_BYTES 20

	@@ -91,7 +93,7 @@ struct hdac_hdmi_dai_pin_map {
	};		};

	struct hdac_hdmi_priv {		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 pin_list;
	struct list_head cvt_list;		struct list_head cvt_list;
	struct list_head pcm_list;		struct list_head pcm_list;
	@@ -384,44 +386,136 @@ static int hdac_hdmi_playback_cleanup(struct snd_pcm_substream *substream,
	return 0;		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,		static int hdac_hdmi_pcm_open(struct snd_pcm_substream *substream,
	struct snd_soc_dai *dai)		struct snd_soc_dai *dai)
	{		{
	struct hdac_ext_device *hdac = snd_soc_dai_get_drvdata(dai);		struct hdac_ext_device *hdac = snd_soc_dai_get_drvdata(dai);
	struct hdac_hdmi_priv *hdmi = hdac->private_data;		struct hdac_hdmi_priv *hdmi = hdac->private_data;
	struct hdac_hdmi_dai_pin_map *dai_map;		struct hdac_hdmi_dai_pin_map *dai_map;
			struct hdac_hdmi_cvt *cvt;
			struct hdac_hdmi_pin *pin;
	int ret;		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];		dai_map = &hdmi->dai_map[dai->id];

	if ((!dai_map->pin->eld.monitor_present) \|\|		cvt = dai_map->cvt;
	(!dai_map->pin->eld.eld_valid)) {		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,		dev_err(&hdac->hdac.dev,
	"Failed: montior present? %d ELD valid?: %d\n",		"Failed: montior present? %d ELD valid?: %d for pin: %d\n",
	dai_map->pin->eld.monitor_present,		pin->eld.monitor_present, pin->eld.eld_valid, pin->nid);
	dai_map->pin->eld.eld_valid);

	return -ENODEV;		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,		ret = hdac_hdmi_enable_pin(hdac, dai_map);
	AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);		if (ret < 0)
			return ret;

	ret = hdac_hdmi_eld_limit_formats(substream->runtime,		ret = hdac_hdmi_eld_limit_formats(substream->runtime,
	dai_map->pin->eld.eld_buffer);		pin->eld.eld_buffer);
	if (ret < 0)		if (ret < 0)
	return ret;		return ret;

	return snd_pcm_hw_constraint_eld(substream->runtime,		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,		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,		snd_hdac_codec_write(&hdac->hdac, dai_map->pin->nid, 0,
	AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);		AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);

			dai_map->pin = NULL;
	}		}

	static int		static int
	@@ -759,30 +855,18 @@ 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)		static int hdac_hdmi_init_dai_map(struct hdac_ext_device *edev)
	{		{
	struct hdac_hdmi_priv *hdmi = edev->private_data;		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_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;		return -EINVAL;

	/*		list_for_each_entry(cvt, &hdmi->cvt_list, head) {
	* Currently on board only 1 pin and 1 converter is enabled for		dai_map = &hdmi->dai_map[dai_id];
	* simplification, more will be added eventually		dai_map->dai_id = dai_id;
	* 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;

	dai_map->cvt = cvt;		dai_map->cvt = cvt;

	/* Enable out path for this pin widget */
	snd_hdac_codec_write(&edev->hdac, pin->nid, 0,
	AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);

	/* Enable transmission */		/* Enable transmission */
	snd_hdac_codec_write(&edev->hdac, cvt->nid, 0,		snd_hdac_codec_write(&edev->hdac, cvt->nid, 0,
	AC_VERB_SET_DIGI_CONVERT_1, 1);		AC_VERB_SET_DIGI_CONVERT_1, 1);
	@@ -791,8 +875,14 @@ static int hdac_hdmi_init_dai_map(struct hdac_ext_device *edev)
	snd_hdac_codec_write(&edev->hdac, cvt->nid, 0,		snd_hdac_codec_write(&edev->hdac, cvt->nid, 0,
	AC_VERB_SET_DIGI_CONVERT_2, 0);		AC_VERB_SET_DIGI_CONVERT_2, 0);

	snd_hdac_codec_write(&edev->hdac, pin->nid, 0,		dai_id++;
	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;		return 0;
	}		}