Merge "msm: mdss: add pinctrl support to HDMI driver" (e3e080de) · Commits · e / devices / android_kernel_sony_msm8994

Documentation/devicetree/bindings/fb/msm-hdmi-tx.txt

+17 −0

Original line number	Diff line number	Diff line
		@@ -39,6 +39,10 @@ Optional properties:
		Required property for MTP devices which are reworked to expose HDMI port.
		- qcom,hdmi-tx-hpd: gpio required for HDMI hot-plug detect. Required on
		platforms where companion chip is not used.
		- pinctrl-names: a list of strings that map to the pinctrl states.
		- pinctrl-0: list of phandles, each pointing at a pin configuration node.
		...
		- pinctrl-n: list of phandles, each pointing at a pin configuration node.

		[Optional child nodes]: These nodes are for devices which are
		dependent on HDMI Tx controller. If HDMI Tx controller is disabled then
		@@ -83,4 +87,17 @@ Example:
		qcom,msm-hdmi-audio-rx {
		compatible = "qcom,msm-hdmi-audio-codec-rx";
		};
		pinctrl-names = "hdmi_hpd_active", "hdmi_ddc_active",
		"hdmi_cec_active", "hdmi_active",
		"hdmi_sleep";
		pinctrl-0 = <&mdss_hdmi_hpd_active &mdss_hdmi_ddc_suspend
		&mdss_hdmi_cec_suspend>;
		pinctrl-1 = <&mdss_hdmi_hpd_active &mdss_hdmi_ddc_active
		&mdss_hdmi_cec_suspend>;
		pinctrl-2 = <&mdss_hdmi_hpd_active &mdss_hdmi_cec_active
		&mdss_hdmi_ddc_suspend>;
		pinctrl-3 = <&mdss_hdmi_hpd_active &mdss_hdmi_ddc_active
		&mdss_hdmi_cec_active>;
		pinctrl-4 = <&mdss_hdmi_hpd_suspend &mdss_hdmi_ddc_suspend
		&mdss_hdmi_cec_suspend>;
		};

drivers/video/msm/mdss/mdss_hdmi_tx.c

+108 −0

Original line number	Diff line number	Diff line
		@@ -1800,6 +1800,104 @@ static void hdmi_tx_set_mode(struct hdmi_tx_ctrl *hdmi_ctrl, u32 power_on)
		power_on ? "Enable" : "Disable", reg_val);
		} /* hdmi_tx_set_mode */

		static int hdmi_tx_pinctrl_set_state(struct hdmi_tx_ctrl *hdmi_ctrl,
		enum hdmi_tx_power_module_type module, bool active)
		{
		struct pinctrl_state *pin_state;
		int rc = -EFAULT;
		struct dss_module_power *power_data = NULL;
		u64 cur_pin_states;

		if (!hdmi_ctrl) {
		DEV_ERR("%s: invalid input\n", __func__);
		return -ENODEV;
		}

		if (IS_ERR_OR_NULL(hdmi_ctrl->pin_res.pinctrl))
		return 0;

		power_data = &hdmi_ctrl->pdata.power_data[module];

		cur_pin_states = active ? (hdmi_ctrl->pdata.pin_states \| BIT(module))
		: (hdmi_ctrl->pdata.pin_states & ~BIT(module));

		if (cur_pin_states & BIT(HDMI_TX_HPD_PM)) {
		if (cur_pin_states & BIT(HDMI_TX_DDC_PM)) {
		if (cur_pin_states & BIT(HDMI_TX_CEC_PM))
		pin_state = hdmi_ctrl->pin_res.state_active;
		else
		pin_state =
		hdmi_ctrl->pin_res.state_ddc_active;
		} else if (cur_pin_states & BIT(HDMI_TX_CEC_PM)) {
		pin_state = hdmi_ctrl->pin_res.state_cec_active;
		} else {
		pin_state = hdmi_ctrl->pin_res.state_hpd_active;
		}
		} else {
		pin_state = hdmi_ctrl->pin_res.state_suspend;
		}

		if (!IS_ERR_OR_NULL(pin_state)) {
		rc = pinctrl_select_state(hdmi_ctrl->pin_res.pinctrl,
		pin_state);
		if (rc)
		pr_err("%s: cannot set pins\n", __func__);
		else
		hdmi_ctrl->pdata.pin_states = cur_pin_states;
		} else {
		pr_err("%s: pinstate not found\n", __func__);
		}

		return rc;
		}

		static int hdmi_tx_pinctrl_init(struct platform_device *pdev)
		{
		struct hdmi_tx_ctrl *hdmi_ctrl;

		hdmi_ctrl = platform_get_drvdata(pdev);
		if (!hdmi_ctrl) {
		DEV_ERR("%s: invalid input\n", __func__);
		return -ENODEV;
		}

		hdmi_ctrl->pin_res.pinctrl = devm_pinctrl_get(&pdev->dev);
		if (IS_ERR_OR_NULL(hdmi_ctrl->pin_res.pinctrl)) {
		pr_err("%s: failed to get pinctrl\n", __func__);
		return PTR_ERR(hdmi_ctrl->pin_res.pinctrl);
		}

		hdmi_ctrl->pin_res.state_active =
		pinctrl_lookup_state(hdmi_ctrl->pin_res.pinctrl, "hdmi_active");
		if (IS_ERR_OR_NULL(hdmi_ctrl->pin_res.state_active))
		pr_debug("%s: cannot get active pinstate\n", __func__);

		hdmi_ctrl->pin_res.state_hpd_active =
		pinctrl_lookup_state(hdmi_ctrl->pin_res.pinctrl,
		"hdmi_hpd_active");
		if (IS_ERR_OR_NULL(hdmi_ctrl->pin_res.state_hpd_active))
		pr_debug("%s: cannot get hpd active pinstate\n", __func__);

		hdmi_ctrl->pin_res.state_cec_active =
		pinctrl_lookup_state(hdmi_ctrl->pin_res.pinctrl,
		"hdmi_cec_active");
		if (IS_ERR_OR_NULL(hdmi_ctrl->pin_res.state_cec_active))
		pr_debug("%s: cannot get cec active pinstate\n", __func__);

		hdmi_ctrl->pin_res.state_ddc_active =
		pinctrl_lookup_state(hdmi_ctrl->pin_res.pinctrl,
		"hdmi_ddc_active");
		if (IS_ERR_OR_NULL(hdmi_ctrl->pin_res.state_ddc_active))
		pr_debug("%s: cannot get ddc active pinstate\n", __func__);

		hdmi_ctrl->pin_res.state_suspend =
		pinctrl_lookup_state(hdmi_ctrl->pin_res.pinctrl, "hdmi_sleep");
		if (IS_ERR_OR_NULL(hdmi_ctrl->pin_res.state_suspend))
		pr_debug("%s: cannot get sleep pinstate\n", __func__);

		return 0;
		}

		static int hdmi_tx_config_power(struct hdmi_tx_ctrl *hdmi_ctrl,
		enum hdmi_tx_power_module_type module, int config)
		{
		@@ -1879,6 +1977,13 @@ static int hdmi_tx_enable_power(struct hdmi_tx_ctrl *hdmi_ctrl,
		goto error;
		}

		rc = hdmi_tx_pinctrl_set_state(hdmi_ctrl, module, enable);
		if (rc) {
		DEV_ERR("%s: Failed to set %s pinctrl state\n",
		__func__, hdmi_tx_pm_name(module));
		goto error;
		}

		rc = msm_dss_enable_gpio(power_data->gpio_config,
		power_data->num_gpio, 1);
		if (rc) {
		@@ -1907,6 +2012,7 @@ static int hdmi_tx_enable_power(struct hdmi_tx_ctrl *hdmi_ctrl,
		power_data->num_clk, 0);
		msm_dss_enable_gpio(power_data->gpio_config,
		power_data->num_gpio, 0);
		hdmi_tx_pinctrl_set_state(hdmi_ctrl, module, 0);
		msm_dss_enable_vreg(power_data->vreg_config,
		power_data->num_vreg, 0);
		}
		@@ -3347,6 +3453,8 @@ static int hdmi_tx_init_resource(struct hdmi_tx_ctrl *hdmi_ctrl)

		pdata = &hdmi_ctrl->pdata;

		hdmi_tx_pinctrl_init(hdmi_ctrl->pdev);

		/* IO */
		for (i = 0; i < HDMI_TX_MAX_IO; i++) {
		rc = msm_dss_ioremap_byname(hdmi_ctrl->pdev, &pdata->io[i],

drivers/video/msm/mdss/mdss_hdmi_tx.h

+12 −0

Original line number	Diff line number	Diff line
		@@ -37,6 +37,8 @@ struct hdmi_tx_platform_data {
		bool cond_power_on;
		struct dss_io_data io[HDMI_TX_MAX_IO];
		struct dss_module_power power_data[HDMI_TX_MAX_PM];
		/* bitfield representing each module's pin state */
		u64 pin_states;
		};

		struct hdmi_audio {
		@@ -47,11 +49,21 @@ struct hdmi_audio {
		int down_mix;
		};

		struct hdmi_tx_pinctrl {
		struct pinctrl *pinctrl;
		struct pinctrl_state *state_active;
		struct pinctrl_state *state_hpd_active;
		struct pinctrl_state *state_cec_active;
		struct pinctrl_state *state_ddc_active;
		struct pinctrl_state *state_suspend;
		};

		struct hdmi_tx_ctrl {
		struct platform_device *pdev;
		struct hdmi_tx_platform_data pdata;
		struct mdss_panel_data panel_data;

		struct hdmi_tx_pinctrl pin_res;
		struct hdmi_audio audio_data;

		struct mutex mutex;