drm/msm: rename hdmi symbols (fcda50c8) · Commits · 戴 / test

drivers/gpu/drm/msm/hdmi/hdmi.c

+49 −49

Original line number	Original line	Diff line number	Diff line
	@@ -21,7 +21,7 @@

	#include "hdmi.h"		#include "hdmi.h"

	void hdmi_set_mode(struct hdmi *hdmi, bool power_on)		void msm_hdmi_set_mode(struct hdmi *hdmi, bool power_on)
	{		{
	uint32_t ctrl = 0;		uint32_t ctrl = 0;
	unsigned long flags;		unsigned long flags;
	@@ -46,26 +46,26 @@ void hdmi_set_mode(struct hdmi *hdmi, bool power_on)
	power_on ? "Enable" : "Disable", ctrl);		power_on ? "Enable" : "Disable", ctrl);
	}		}

	static irqreturn_t hdmi_irq(int irq, void *dev_id)		static irqreturn_t msm_hdmi_irq(int irq, void *dev_id)
	{		{
	struct hdmi *hdmi = dev_id;		struct hdmi *hdmi = dev_id;

	/* Process HPD: */		/* Process HPD: */
	hdmi_connector_irq(hdmi->connector);		msm_hdmi_connector_irq(hdmi->connector);

	/* Process DDC: */		/* Process DDC: */
	hdmi_i2c_irq(hdmi->i2c);		msm_hdmi_i2c_irq(hdmi->i2c);

	/* Process HDCP: */		/* Process HDCP: */
	if (hdmi->hdcp_ctrl)		if (hdmi->hdcp_ctrl)
	hdmi_hdcp_irq(hdmi->hdcp_ctrl);		msm_hdmi_hdcp_irq(hdmi->hdcp_ctrl);

	/* TODO audio.. */		/* TODO audio.. */

	return IRQ_HANDLED;		return IRQ_HANDLED;
	}		}

	static void hdmi_destroy(struct hdmi *hdmi)		static void msm_hdmi_destroy(struct hdmi *hdmi)
	{		{
	/*		/*
	* at this point, hpd has been disabled,		* at this point, hpd has been disabled,
	@@ -75,7 +75,7 @@ static void hdmi_destroy(struct hdmi *hdmi)
	flush_workqueue(hdmi->workq);		flush_workqueue(hdmi->workq);
	destroy_workqueue(hdmi->workq);		destroy_workqueue(hdmi->workq);
	}		}
	hdmi_hdcp_destroy(hdmi);		msm_hdmi_hdcp_destroy(hdmi);

	if (hdmi->phy_dev) {		if (hdmi->phy_dev) {
	put_device(hdmi->phy_dev);		put_device(hdmi->phy_dev);
	@@ -84,12 +84,12 @@ static void hdmi_destroy(struct hdmi *hdmi)
	}		}

	if (hdmi->i2c)		if (hdmi->i2c)
	hdmi_i2c_destroy(hdmi->i2c);		msm_hdmi_i2c_destroy(hdmi->i2c);

	platform_set_drvdata(hdmi->pdev, NULL);		platform_set_drvdata(hdmi->pdev, NULL);
	}		}

	static int hdmi_get_phy(struct hdmi *hdmi)		static int msm_hdmi_get_phy(struct hdmi *hdmi)
	{		{
	struct platform_device *pdev = hdmi->pdev;		struct platform_device *pdev = hdmi->pdev;
	struct platform_device *phy_pdev;		struct platform_device *phy_pdev;
	@@ -121,7 +121,7 @@ static int hdmi_get_phy(struct hdmi *hdmi)
	* we are to EPROBE_DEFER we want to do it here, rather than later		* we are to EPROBE_DEFER we want to do it here, rather than later
	* at modeset_init() time		* at modeset_init() time
	*/		*/
	static struct hdmi hdmi_init(struct platform_device pdev)		static struct hdmi msm_hdmi_init(struct platform_device pdev)
	{		{
	struct hdmi_platform_config *config = pdev->dev.platform_data;		struct hdmi_platform_config *config = pdev->dev.platform_data;
	struct hdmi *hdmi = NULL;		struct hdmi *hdmi = NULL;
	@@ -240,7 +240,7 @@ static struct hdmi hdmi_init(struct platform_device pdev)

	hdmi->workq = alloc_ordered_workqueue("msm_hdmi", 0);		hdmi->workq = alloc_ordered_workqueue("msm_hdmi", 0);

	hdmi->i2c = hdmi_i2c_init(hdmi);		hdmi->i2c = msm_hdmi_i2c_init(hdmi);
	if (IS_ERR(hdmi->i2c)) {		if (IS_ERR(hdmi->i2c)) {
	ret = PTR_ERR(hdmi->i2c);		ret = PTR_ERR(hdmi->i2c);
	dev_err(&pdev->dev, "failed to get i2c: %d\n", ret);		dev_err(&pdev->dev, "failed to get i2c: %d\n", ret);
	@@ -248,13 +248,13 @@ static struct hdmi hdmi_init(struct platform_device pdev)
	goto fail;		goto fail;
	}		}

	ret = hdmi_get_phy(hdmi);		ret = msm_hdmi_get_phy(hdmi);
	if (ret) {		if (ret) {
	dev_err(&pdev->dev, "failed to get phy\n");		dev_err(&pdev->dev, "failed to get phy\n");
	goto fail;		goto fail;
	}		}

	hdmi->hdcp_ctrl = hdmi_hdcp_init(hdmi);		hdmi->hdcp_ctrl = msm_hdmi_hdcp_init(hdmi);
	if (IS_ERR(hdmi->hdcp_ctrl)) {		if (IS_ERR(hdmi->hdcp_ctrl)) {
	dev_warn(&pdev->dev, "failed to init hdcp: disabled\n");		dev_warn(&pdev->dev, "failed to init hdcp: disabled\n");
	hdmi->hdcp_ctrl = NULL;		hdmi->hdcp_ctrl = NULL;
	@@ -264,7 +264,7 @@ static struct hdmi hdmi_init(struct platform_device pdev)

	fail:		fail:
	if (hdmi)		if (hdmi)
	hdmi_destroy(hdmi);		msm_hdmi_destroy(hdmi);

	return ERR_PTR(ret);		return ERR_PTR(ret);
	}		}
	@@ -274,10 +274,10 @@ fail:
	* driver (not hdmi sub-device's probe/bind!)		* driver (not hdmi sub-device's probe/bind!)
	*		*
	* Any resource (regulator/clk/etc) which could be missing at boot		* Any resource (regulator/clk/etc) which could be missing at boot
	* should be handled in hdmi_init() so that failure happens from		* should be handled in msm_hdmi_init() so that failure happens from
	* hdmi sub-device's probe.		* hdmi sub-device's probe.
	*/		*/
	int hdmi_modeset_init(struct hdmi *hdmi,		int msm_hdmi_modeset_init(struct hdmi *hdmi,
	struct drm_device dev, struct drm_encoder encoder)		struct drm_device dev, struct drm_encoder encoder)
	{		{
	struct msm_drm_private *priv = dev->dev_private;		struct msm_drm_private *priv = dev->dev_private;
	@@ -289,7 +289,7 @@ int hdmi_modeset_init(struct hdmi *hdmi,

	hdmi_audio_infoframe_init(&hdmi->audio.infoframe);		hdmi_audio_infoframe_init(&hdmi->audio.infoframe);

	hdmi->bridge = hdmi_bridge_init(hdmi);		hdmi->bridge = msm_hdmi_bridge_init(hdmi);
	if (IS_ERR(hdmi->bridge)) {		if (IS_ERR(hdmi->bridge)) {
	ret = PTR_ERR(hdmi->bridge);		ret = PTR_ERR(hdmi->bridge);
	dev_err(dev->dev, "failed to create HDMI bridge: %d\n", ret);		dev_err(dev->dev, "failed to create HDMI bridge: %d\n", ret);
	@@ -297,7 +297,7 @@ int hdmi_modeset_init(struct hdmi *hdmi,
	goto fail;		goto fail;
	}		}

	hdmi->connector = hdmi_connector_init(hdmi);		hdmi->connector = msm_hdmi_connector_init(hdmi);
	if (IS_ERR(hdmi->connector)) {		if (IS_ERR(hdmi->connector)) {
	ret = PTR_ERR(hdmi->connector);		ret = PTR_ERR(hdmi->connector);
	dev_err(dev->dev, "failed to create HDMI connector: %d\n", ret);		dev_err(dev->dev, "failed to create HDMI connector: %d\n", ret);
	@@ -313,7 +313,7 @@ int hdmi_modeset_init(struct hdmi *hdmi,
	}		}

	ret = devm_request_irq(&pdev->dev, hdmi->irq,		ret = devm_request_irq(&pdev->dev, hdmi->irq,
	hdmi_irq, IRQF_TRIGGER_HIGH \| IRQF_ONESHOT,		msm_hdmi_irq, IRQF_TRIGGER_HIGH \| IRQF_ONESHOT,
	"hdmi_isr", hdmi);		"hdmi_isr", hdmi);
	if (ret < 0) {		if (ret < 0) {
	dev_err(dev->dev, "failed to request IRQ%u: %d\n",		dev_err(dev->dev, "failed to request IRQ%u: %d\n",
	@@ -333,7 +333,7 @@ int hdmi_modeset_init(struct hdmi *hdmi,
	fail:		fail:
	/* bridge is normally destroyed by drm: */		/* bridge is normally destroyed by drm: */
	if (hdmi->bridge) {		if (hdmi->bridge) {
	hdmi_bridge_destroy(hdmi->bridge);		msm_hdmi_bridge_destroy(hdmi->bridge);
	hdmi->bridge = NULL;		hdmi->bridge = NULL;
	}		}
	if (hdmi->connector) {		if (hdmi->connector) {
	@@ -410,7 +410,7 @@ static const struct {
	const bool output;		const bool output;
	const int value;		const int value;
	const char *label;		const char *label;
	} hdmi_gpio_pdata[] = {		} msm_hdmi_gpio_pdata[] = {
	{ "qcom,hdmi-tx-ddc-clk", true, 1, "HDMI_DDC_CLK" },		{ "qcom,hdmi-tx-ddc-clk", true, 1, "HDMI_DDC_CLK" },
	{ "qcom,hdmi-tx-ddc-data", true, 1, "HDMI_DDC_DATA" },		{ "qcom,hdmi-tx-ddc-data", true, 1, "HDMI_DDC_DATA" },
	{ "qcom,hdmi-tx-hpd", false, 1, "HDMI_HPD" },		{ "qcom,hdmi-tx-hpd", false, 1, "HDMI_HPD" },
	@@ -419,7 +419,7 @@ static const struct {
	{ "qcom,hdmi-tx-mux-lpm", true, 1, "HDMI_MUX_LPM" },		{ "qcom,hdmi-tx-mux-lpm", true, 1, "HDMI_MUX_LPM" },
	};		};

	static int get_gpio(struct device_node of_node, const char name)		static int msm_hdmi_get_gpio(struct device_node of_node, const char name)
	{		{
	int gpio = of_get_named_gpio(of_node, name, 0);		int gpio = of_get_named_gpio(of_node, name, 0);
	if (gpio < 0) {		if (gpio < 0) {
	@@ -434,7 +434,7 @@ static int get_gpio(struct device_node of_node, const char name)
	return gpio;		return gpio;
	}		}

	static int hdmi_bind(struct device dev, struct device master, void *data)		static int msm_hdmi_bind(struct device dev, struct device master, void *data)
	{		{
	struct drm_device *drm = dev_get_drvdata(master);		struct drm_device *drm = dev_get_drvdata(master);
	struct msm_drm_private *priv = drm->dev_private;		struct msm_drm_private *priv = drm->dev_private;
	@@ -454,16 +454,16 @@ static int hdmi_bind(struct device dev, struct device master, void *data)
	hdmi_cfg->qfprom_mmio_name = "qfprom_physical";		hdmi_cfg->qfprom_mmio_name = "qfprom_physical";

	for (i = 0; i < HDMI_MAX_NUM_GPIO; i++) {		for (i = 0; i < HDMI_MAX_NUM_GPIO; i++) {
	hdmi_cfg->gpios[i].num = get_gpio(of_node,		hdmi_cfg->gpios[i].num = msm_hdmi_get_gpio(of_node,
	hdmi_gpio_pdata[i].name);		msm_hdmi_gpio_pdata[i].name);
	hdmi_cfg->gpios[i].output = hdmi_gpio_pdata[i].output;		hdmi_cfg->gpios[i].output = msm_hdmi_gpio_pdata[i].output;
	hdmi_cfg->gpios[i].value = hdmi_gpio_pdata[i].value;		hdmi_cfg->gpios[i].value = msm_hdmi_gpio_pdata[i].value;
	hdmi_cfg->gpios[i].label = hdmi_gpio_pdata[i].label;		hdmi_cfg->gpios[i].label = msm_hdmi_gpio_pdata[i].label;
	}		}

	dev->platform_data = hdmi_cfg;		dev->platform_data = hdmi_cfg;

	hdmi = hdmi_init(to_platform_device(dev));		hdmi = msm_hdmi_init(to_platform_device(dev));
	if (IS_ERR(hdmi))		if (IS_ERR(hdmi))
	return PTR_ERR(hdmi);		return PTR_ERR(hdmi);
	priv->hdmi = hdmi;		priv->hdmi = hdmi;
	@@ -471,34 +471,34 @@ static int hdmi_bind(struct device dev, struct device master, void *data)
	return 0;		return 0;
	}		}

	static void hdmi_unbind(struct device dev, struct device master,		static void msm_hdmi_unbind(struct device dev, struct device master,
	void *data)		void *data)
	{		{
	struct drm_device *drm = dev_get_drvdata(master);		struct drm_device *drm = dev_get_drvdata(master);
	struct msm_drm_private *priv = drm->dev_private;		struct msm_drm_private *priv = drm->dev_private;
	if (priv->hdmi) {		if (priv->hdmi) {
	hdmi_destroy(priv->hdmi);		msm_hdmi_destroy(priv->hdmi);
	priv->hdmi = NULL;		priv->hdmi = NULL;
	}		}
	}		}

	static const struct component_ops hdmi_ops = {		static const struct component_ops msm_hdmi_ops = {
	.bind = hdmi_bind,		.bind = msm_hdmi_bind,
	.unbind = hdmi_unbind,		.unbind = msm_hdmi_unbind,
	};		};

	static int hdmi_dev_probe(struct platform_device *pdev)		static int msm_hdmi_dev_probe(struct platform_device *pdev)
	{		{
	return component_add(&pdev->dev, &hdmi_ops);		return component_add(&pdev->dev, &msm_hdmi_ops);
	}		}

	static int hdmi_dev_remove(struct platform_device *pdev)		static int msm_hdmi_dev_remove(struct platform_device *pdev)
	{		{
	component_del(&pdev->dev, &hdmi_ops);		component_del(&pdev->dev, &msm_hdmi_ops);
	return 0;		return 0;
	}		}

	static const struct of_device_id dt_match[] = {		static const struct of_device_id msm_hdmi_dt_match[] = {
	{ .compatible = "qcom,hdmi-tx-8996", .data = &hdmi_tx_8996_config },		{ .compatible = "qcom,hdmi-tx-8996", .data = &hdmi_tx_8996_config },
	{ .compatible = "qcom,hdmi-tx-8994", .data = &hdmi_tx_8994_config },		{ .compatible = "qcom,hdmi-tx-8994", .data = &hdmi_tx_8994_config },
	{ .compatible = "qcom,hdmi-tx-8084", .data = &hdmi_tx_8084_config },		{ .compatible = "qcom,hdmi-tx-8084", .data = &hdmi_tx_8084_config },
	@@ -508,23 +508,23 @@ static const struct of_device_id dt_match[] = {
	{}		{}
	};		};

	static struct platform_driver hdmi_driver = {		static struct platform_driver msm_hdmi_driver = {
	.probe = hdmi_dev_probe,		.probe = msm_hdmi_dev_probe,
	.remove = hdmi_dev_remove,		.remove = msm_hdmi_dev_remove,
	.driver = {		.driver = {
	.name = "hdmi_msm",		.name = "hdmi_msm",
	.of_match_table = dt_match,		.of_match_table = msm_hdmi_dt_match,
	},		},
	};		};

	void __init hdmi_register(void)		void __init msm_hdmi_register(void)
	{		{
	hdmi_phy_driver_register();		msm_hdmi_phy_driver_register();
	platform_driver_register(&hdmi_driver);		platform_driver_register(&msm_hdmi_driver);
	}		}

	void __exit hdmi_unregister(void)		void __exit msm_hdmi_unregister(void)
	{		{
	platform_driver_unregister(&hdmi_driver);		platform_driver_unregister(&msm_hdmi_driver);
	hdmi_phy_driver_unregister();		msm_hdmi_phy_driver_unregister();
	}		}

drivers/gpu/drm/msm/hdmi/hdmi.h

+30 −30

Original line number	Original line	Diff line number	Diff line
	@@ -122,7 +122,7 @@ struct hdmi_platform_config {
	struct hdmi_gpio_data gpios[HDMI_MAX_NUM_GPIO];		struct hdmi_gpio_data gpios[HDMI_MAX_NUM_GPIO];
	};		};

	void hdmi_set_mode(struct hdmi *hdmi, bool power_on);		void msm_hdmi_set_mode(struct hdmi *hdmi, bool power_on);

	static inline void hdmi_write(struct hdmi *hdmi, u32 reg, u32 data)		static inline void hdmi_write(struct hdmi *hdmi, u32 reg, u32 data)
	{		{
	@@ -161,10 +161,10 @@ struct hdmi_phy_cfg {
	int num_clks;		int num_clks;
	};		};

	extern const struct hdmi_phy_cfg hdmi_phy_8x60_cfg;		extern const struct hdmi_phy_cfg msm_hdmi_phy_8x60_cfg;
	extern const struct hdmi_phy_cfg hdmi_phy_8960_cfg;		extern const struct hdmi_phy_cfg msm_hdmi_phy_8960_cfg;
	extern const struct hdmi_phy_cfg hdmi_phy_8x74_cfg;		extern const struct hdmi_phy_cfg msm_hdmi_phy_8x74_cfg;
	extern const struct hdmi_phy_cfg hdmi_phy_8996_cfg;		extern const struct hdmi_phy_cfg msm_hdmi_phy_8996_cfg;

	struct hdmi_phy {		struct hdmi_phy {
	struct platform_device *pdev;		struct platform_device *pdev;
	@@ -185,23 +185,23 @@ static inline u32 hdmi_phy_read(struct hdmi_phy *phy, u32 reg)
	return msm_readl(phy->mmio + reg);		return msm_readl(phy->mmio + reg);
	}		}

	int hdmi_phy_resource_enable(struct hdmi_phy *phy);		int msm_hdmi_phy_resource_enable(struct hdmi_phy *phy);
	void hdmi_phy_resource_disable(struct hdmi_phy *phy);		void msm_hdmi_phy_resource_disable(struct hdmi_phy *phy);
	void hdmi_phy_powerup(struct hdmi_phy *phy, unsigned long int pixclock);		void msm_hdmi_phy_powerup(struct hdmi_phy *phy, unsigned long int pixclock);
	void hdmi_phy_powerdown(struct hdmi_phy *phy);		void msm_hdmi_phy_powerdown(struct hdmi_phy *phy);
	void __init hdmi_phy_driver_register(void);		void __init msm_hdmi_phy_driver_register(void);
	void __exit hdmi_phy_driver_unregister(void);		void __exit msm_hdmi_phy_driver_unregister(void);

	#ifdef CONFIG_COMMON_CLK		#ifdef CONFIG_COMMON_CLK
	int hdmi_pll_8960_init(struct platform_device *pdev);		int msm_hdmi_pll_8960_init(struct platform_device *pdev);
	int hdmi_pll_8996_init(struct platform_device *pdev);		int msm_hdmi_pll_8996_init(struct platform_device *pdev);
	#else		#else
	int hdmi_pll_8960_init(struct platform_device *pdev);		static inline int msm_hdmi_pll_8960_init(struct platform_device *pdev);
	{		{
	return -ENODEV;		return -ENODEV;
	}		}

	int hdmi_pll_8996_init(struct platform_device *pdev)		static inline int msm_hdmi_pll_8996_init(struct platform_device *pdev)
	{		{
	return -ENODEV;		return -ENODEV;
	}		}
	@@ -211,42 +211,42 @@ int hdmi_pll_8996_init(struct platform_device *pdev)
	* audio:		* audio:
	*/		*/

	int hdmi_audio_update(struct hdmi *hdmi);		int msm_hdmi_audio_update(struct hdmi *hdmi);
	int hdmi_audio_info_setup(struct hdmi *hdmi, bool enabled,		int msm_hdmi_audio_info_setup(struct hdmi *hdmi, bool enabled,
	uint32_t num_of_channels, uint32_t channel_allocation,		uint32_t num_of_channels, uint32_t channel_allocation,
	uint32_t level_shift, bool down_mix);		uint32_t level_shift, bool down_mix);
	void hdmi_audio_set_sample_rate(struct hdmi *hdmi, int rate);		void msm_hdmi_audio_set_sample_rate(struct hdmi *hdmi, int rate);


	/*		/*
	* hdmi bridge:		* hdmi bridge:
	*/		*/

	struct drm_bridge hdmi_bridge_init(struct hdmi hdmi);		struct drm_bridge msm_hdmi_bridge_init(struct hdmi hdmi);
	void hdmi_bridge_destroy(struct drm_bridge *bridge);		void msm_hdmi_bridge_destroy(struct drm_bridge *bridge);

	/*		/*
	* hdmi connector:		* hdmi connector:
	*/		*/

	void hdmi_connector_irq(struct drm_connector *connector);		void msm_hdmi_connector_irq(struct drm_connector *connector);
	struct drm_connector hdmi_connector_init(struct hdmi hdmi);		struct drm_connector msm_hdmi_connector_init(struct hdmi hdmi);

	/*		/*
	* i2c adapter for ddc:		* i2c adapter for ddc:
	*/		*/

	void hdmi_i2c_irq(struct i2c_adapter *i2c);		void msm_hdmi_i2c_irq(struct i2c_adapter *i2c);
	void hdmi_i2c_destroy(struct i2c_adapter *i2c);		void msm_hdmi_i2c_destroy(struct i2c_adapter *i2c);
	struct i2c_adapter hdmi_i2c_init(struct hdmi hdmi);		struct i2c_adapter msm_hdmi_i2c_init(struct hdmi hdmi);

	/*		/*
	* hdcp		* hdcp
	*/		*/
	struct hdmi_hdcp_ctrl hdmi_hdcp_init(struct hdmi hdmi);		struct hdmi_hdcp_ctrl msm_hdmi_hdcp_init(struct hdmi hdmi);
	void hdmi_hdcp_destroy(struct hdmi *hdmi);		void msm_hdmi_hdcp_destroy(struct hdmi *hdmi);
	void hdmi_hdcp_on(struct hdmi_hdcp_ctrl *hdcp_ctrl);		void msm_hdmi_hdcp_on(struct hdmi_hdcp_ctrl *hdcp_ctrl);
	void hdmi_hdcp_off(struct hdmi_hdcp_ctrl *hdcp_ctrl);		void msm_hdmi_hdcp_off(struct hdmi_hdcp_ctrl *hdcp_ctrl);
	void hdmi_hdcp_irq(struct hdmi_hdcp_ctrl *hdcp_ctrl);		void msm_hdmi_hdcp_irq(struct hdmi_hdcp_ctrl *hdcp_ctrl);

	#endif /* __HDMI_CONNECTOR_H__ */		#endif /* __HDMI_CONNECTOR_H__ */

drivers/gpu/drm/msm/hdmi/hdmi_audio.c

+5 −5

Original line number	Original line	Diff line number	Diff line
	@@ -89,7 +89,7 @@ static const struct hdmi_msm_audio_arcs *get_arcs(unsigned long int pixclock)
	return NULL;		return NULL;
	}		}

	int hdmi_audio_update(struct hdmi *hdmi)		int msm_hdmi_audio_update(struct hdmi *hdmi)
	{		{
	struct hdmi_audio *audio = &hdmi->audio;		struct hdmi_audio *audio = &hdmi->audio;
	struct hdmi_audio_infoframe *info = &audio->infoframe;		struct hdmi_audio_infoframe *info = &audio->infoframe;
	@@ -232,7 +232,7 @@ int hdmi_audio_update(struct hdmi *hdmi)
	return 0;		return 0;
	}		}

	int hdmi_audio_info_setup(struct hdmi *hdmi, bool enabled,		int msm_hdmi_audio_info_setup(struct hdmi *hdmi, bool enabled,
	uint32_t num_of_channels, uint32_t channel_allocation,		uint32_t num_of_channels, uint32_t channel_allocation,
	uint32_t level_shift, bool down_mix)		uint32_t level_shift, bool down_mix)
	{		{
	@@ -252,10 +252,10 @@ int hdmi_audio_info_setup(struct hdmi *hdmi, bool enabled,
	audio->infoframe.level_shift_value = level_shift;		audio->infoframe.level_shift_value = level_shift;
	audio->infoframe.downmix_inhibit = down_mix;		audio->infoframe.downmix_inhibit = down_mix;

	return hdmi_audio_update(hdmi);		return msm_hdmi_audio_update(hdmi);
	}		}

	void hdmi_audio_set_sample_rate(struct hdmi *hdmi, int rate)		void msm_hdmi_audio_set_sample_rate(struct hdmi *hdmi, int rate)
	{		{
	struct hdmi_audio *audio;		struct hdmi_audio *audio;

	@@ -268,5 +268,5 @@ void hdmi_audio_set_sample_rate(struct hdmi *hdmi, int rate)
	return;		return;

	audio->rate = rate;		audio->rate = rate;
	hdmi_audio_update(hdmi);		msm_hdmi_audio_update(hdmi);
	}		}

drivers/gpu/drm/msm/hdmi/hdmi_bridge.c

+28 −28

Original line number	Original line	Diff line number	Diff line
	@@ -23,11 +23,11 @@ struct hdmi_bridge {
	};		};
	#define to_hdmi_bridge(x) container_of(x, struct hdmi_bridge, base)		#define to_hdmi_bridge(x) container_of(x, struct hdmi_bridge, base)

	void hdmi_bridge_destroy(struct drm_bridge *bridge)		void msm_hdmi_bridge_destroy(struct drm_bridge *bridge)
	{		{
	}		}

	static void power_on(struct drm_bridge *bridge)		static void msm_hdmi_power_on(struct drm_bridge *bridge)
	{		{
	struct drm_device *dev = bridge->dev;		struct drm_device *dev = bridge->dev;
	struct hdmi_bridge *hdmi_bridge = to_hdmi_bridge(bridge);		struct hdmi_bridge *hdmi_bridge = to_hdmi_bridge(bridge);
	@@ -86,7 +86,7 @@ static void power_off(struct drm_bridge *bridge)
	}		}
	}		}

	static void hdmi_bridge_pre_enable(struct drm_bridge *bridge)		static void msm_hdmi_bridge_pre_enable(struct drm_bridge *bridge)
	{		{
	struct hdmi_bridge *hdmi_bridge = to_hdmi_bridge(bridge);		struct hdmi_bridge *hdmi_bridge = to_hdmi_bridge(bridge);
	struct hdmi *hdmi = hdmi_bridge->hdmi;		struct hdmi *hdmi = hdmi_bridge->hdmi;
	@@ -95,51 +95,51 @@ static void hdmi_bridge_pre_enable(struct drm_bridge *bridge)
	DBG("power up");		DBG("power up");

	if (!hdmi->power_on) {		if (!hdmi->power_on) {
	hdmi_phy_resource_enable(phy);		msm_hdmi_phy_resource_enable(phy);
	power_on(bridge);		msm_hdmi_power_on(bridge);
	hdmi->power_on = true;		hdmi->power_on = true;
	hdmi_audio_update(hdmi);		msm_hdmi_audio_update(hdmi);
	}		}

	hdmi_phy_powerup(phy, hdmi->pixclock);		msm_hdmi_phy_powerup(phy, hdmi->pixclock);

	hdmi_set_mode(hdmi, true);		msm_hdmi_set_mode(hdmi, true);

	if (hdmi->hdcp_ctrl)		if (hdmi->hdcp_ctrl)
	hdmi_hdcp_on(hdmi->hdcp_ctrl);		msm_hdmi_hdcp_on(hdmi->hdcp_ctrl);
	}		}

	static void hdmi_bridge_enable(struct drm_bridge *bridge)		static void msm_hdmi_bridge_enable(struct drm_bridge *bridge)
	{		{
	}		}

	static void hdmi_bridge_disable(struct drm_bridge *bridge)		static void msm_hdmi_bridge_disable(struct drm_bridge *bridge)
	{		{
	}		}

	static void hdmi_bridge_post_disable(struct drm_bridge *bridge)		static void msm_hdmi_bridge_post_disable(struct drm_bridge *bridge)
	{		{
	struct hdmi_bridge *hdmi_bridge = to_hdmi_bridge(bridge);		struct hdmi_bridge *hdmi_bridge = to_hdmi_bridge(bridge);
	struct hdmi *hdmi = hdmi_bridge->hdmi;		struct hdmi *hdmi = hdmi_bridge->hdmi;
	struct hdmi_phy *phy = hdmi->phy;		struct hdmi_phy *phy = hdmi->phy;

	if (hdmi->hdcp_ctrl)		if (hdmi->hdcp_ctrl)
	hdmi_hdcp_off(hdmi->hdcp_ctrl);		msm_hdmi_hdcp_off(hdmi->hdcp_ctrl);

	DBG("power down");		DBG("power down");
	hdmi_set_mode(hdmi, false);		msm_hdmi_set_mode(hdmi, false);

	hdmi_phy_powerdown(phy);		msm_hdmi_phy_powerdown(phy);

	if (hdmi->power_on) {		if (hdmi->power_on) {
	power_off(bridge);		power_off(bridge);
	hdmi->power_on = false;		hdmi->power_on = false;
	hdmi_audio_update(hdmi);		msm_hdmi_audio_update(hdmi);
	hdmi_phy_resource_disable(phy);		msm_hdmi_phy_resource_disable(phy);
	}		}
	}		}

	static void hdmi_bridge_mode_set(struct drm_bridge *bridge,		static void msm_hdmi_bridge_mode_set(struct drm_bridge *bridge,
	struct drm_display_mode *mode,		struct drm_display_mode *mode,
	struct drm_display_mode *adjusted_mode)		struct drm_display_mode *adjusted_mode)
	{		{
	@@ -196,20 +196,20 @@ static void hdmi_bridge_mode_set(struct drm_bridge *bridge,
	DBG("frame_ctrl=%08x", frame_ctrl);		DBG("frame_ctrl=%08x", frame_ctrl);
	hdmi_write(hdmi, REG_HDMI_FRAME_CTRL, frame_ctrl);		hdmi_write(hdmi, REG_HDMI_FRAME_CTRL, frame_ctrl);

	hdmi_audio_update(hdmi);		msm_hdmi_audio_update(hdmi);
	}		}

	static const struct drm_bridge_funcs hdmi_bridge_funcs = {		static const struct drm_bridge_funcs msm_hdmi_bridge_funcs = {
	.pre_enable = hdmi_bridge_pre_enable,		.pre_enable = msm_hdmi_bridge_pre_enable,
	.enable = hdmi_bridge_enable,		.enable = msm_hdmi_bridge_enable,
	.disable = hdmi_bridge_disable,		.disable = msm_hdmi_bridge_disable,
	.post_disable = hdmi_bridge_post_disable,		.post_disable = msm_hdmi_bridge_post_disable,
	.mode_set = hdmi_bridge_mode_set,		.mode_set = msm_hdmi_bridge_mode_set,
	};		};


	/* initialize bridge */		/* initialize bridge */
	struct drm_bridge hdmi_bridge_init(struct hdmi hdmi)		struct drm_bridge msm_hdmi_bridge_init(struct hdmi hdmi)
	{		{
	struct drm_bridge *bridge = NULL;		struct drm_bridge *bridge = NULL;
	struct hdmi_bridge *hdmi_bridge;		struct hdmi_bridge *hdmi_bridge;
	@@ -225,7 +225,7 @@ struct drm_bridge hdmi_bridge_init(struct hdmi hdmi)
	hdmi_bridge->hdmi = hdmi;		hdmi_bridge->hdmi = hdmi;

	bridge = &hdmi_bridge->base;		bridge = &hdmi_bridge->base;
	bridge->funcs = &hdmi_bridge_funcs;		bridge->funcs = &msm_hdmi_bridge_funcs;

	ret = drm_bridge_attach(hdmi->dev, bridge);		ret = drm_bridge_attach(hdmi->dev, bridge);
	if (ret)		if (ret)
	@@ -235,7 +235,7 @@ struct drm_bridge hdmi_bridge_init(struct hdmi hdmi)

	fail:		fail:
	if (bridge)		if (bridge)
	hdmi_bridge_destroy(bridge);		msm_hdmi_bridge_destroy(bridge);

	return ERR_PTR(ret);		return ERR_PTR(ret);
	}		}

drivers/gpu/drm/msm/hdmi/hdmi_connector.c

+17 −17

Original line number	Original line	Diff line number	Diff line
	@@ -28,7 +28,7 @@ struct hdmi_connector {
	};		};
	#define to_hdmi_connector(x) container_of(x, struct hdmi_connector, base)		#define to_hdmi_connector(x) container_of(x, struct hdmi_connector, base)

	static void hdmi_phy_reset(struct hdmi *hdmi)		static void msm_hdmi_phy_reset(struct hdmi *hdmi)
	{		{
	unsigned int val;		unsigned int val;

	@@ -179,9 +179,9 @@ static int hpd_enable(struct hdmi_connector *hdmi_connector)
	}		}
	}		}

	hdmi_set_mode(hdmi, false);		msm_hdmi_set_mode(hdmi, false);
	hdmi_phy_reset(hdmi);		msm_hdmi_phy_reset(hdmi);
	hdmi_set_mode(hdmi, true);		msm_hdmi_set_mode(hdmi, true);

	hdmi_write(hdmi, REG_HDMI_USEC_REFTIMER, 0x0001001b);		hdmi_write(hdmi, REG_HDMI_USEC_REFTIMER, 0x0001001b);

	@@ -218,7 +218,7 @@ static void hdp_disable(struct hdmi_connector *hdmi_connector)
	/* Disable HPD interrupt */		/* Disable HPD interrupt */
	hdmi_write(hdmi, REG_HDMI_HPD_INT_CTRL, 0);		hdmi_write(hdmi, REG_HDMI_HPD_INT_CTRL, 0);

	hdmi_set_mode(hdmi, false);		msm_hdmi_set_mode(hdmi, false);

	for (i = 0; i < config->hpd_clk_cnt; i++)		for (i = 0; i < config->hpd_clk_cnt; i++)
	clk_disable_unprepare(hdmi->hpd_clks[i]);		clk_disable_unprepare(hdmi->hpd_clks[i]);
	@@ -240,7 +240,7 @@ static void hdp_disable(struct hdmi_connector *hdmi_connector)
	}		}

	static void		static void
	hotplug_work(struct work_struct *work)		msm_hdmi_hotplug_work(struct work_struct *work)
	{		{
	struct hdmi_connector *hdmi_connector =		struct hdmi_connector *hdmi_connector =
	container_of(work, struct hdmi_connector, hpd_work);		container_of(work, struct hdmi_connector, hpd_work);
	@@ -248,7 +248,7 @@ hotplug_work(struct work_struct *work)
	drm_helper_hpd_irq_event(connector->dev);		drm_helper_hpd_irq_event(connector->dev);
	}		}

	void hdmi_connector_irq(struct drm_connector *connector)		void msm_hdmi_connector_irq(struct drm_connector *connector)
	{		{
	struct hdmi_connector *hdmi_connector = to_hdmi_connector(connector);		struct hdmi_connector *hdmi_connector = to_hdmi_connector(connector);
	struct hdmi *hdmi = hdmi_connector->hdmi;		struct hdmi *hdmi = hdmi_connector->hdmi;
	@@ -347,7 +347,7 @@ static void hdmi_connector_destroy(struct drm_connector *connector)
	kfree(hdmi_connector);		kfree(hdmi_connector);
	}		}

	static int hdmi_connector_get_modes(struct drm_connector *connector)		static int msm_hdmi_connector_get_modes(struct drm_connector *connector)
	{		{
	struct hdmi_connector *hdmi_connector = to_hdmi_connector(connector);		struct hdmi_connector *hdmi_connector = to_hdmi_connector(connector);
	struct hdmi *hdmi = hdmi_connector->hdmi;		struct hdmi *hdmi = hdmi_connector->hdmi;
	@@ -373,7 +373,7 @@ static int hdmi_connector_get_modes(struct drm_connector *connector)
	return ret;		return ret;
	}		}

	static int hdmi_connector_mode_valid(struct drm_connector *connector,		static int msm_hdmi_connector_mode_valid(struct drm_connector *connector,
	struct drm_display_mode *mode)		struct drm_display_mode *mode)
	{		{
	struct hdmi_connector *hdmi_connector = to_hdmi_connector(connector);		struct hdmi_connector *hdmi_connector = to_hdmi_connector(connector);
	@@ -403,7 +403,7 @@ static int hdmi_connector_mode_valid(struct drm_connector *connector,
	}		}

	static struct drm_encoder *		static struct drm_encoder *
	hdmi_connector_best_encoder(struct drm_connector *connector)		msm_hdmi_connector_best_encoder(struct drm_connector *connector)
	{		{
	struct hdmi_connector *hdmi_connector = to_hdmi_connector(connector);		struct hdmi_connector *hdmi_connector = to_hdmi_connector(connector);
	return hdmi_connector->hdmi->encoder;		return hdmi_connector->hdmi->encoder;
	@@ -419,14 +419,14 @@ static const struct drm_connector_funcs hdmi_connector_funcs = {
	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,		.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
	};		};

	static const struct drm_connector_helper_funcs hdmi_connector_helper_funcs = {		static const struct drm_connector_helper_funcs msm_hdmi_connector_helper_funcs = {
	.get_modes = hdmi_connector_get_modes,		.get_modes = msm_hdmi_connector_get_modes,
	.mode_valid = hdmi_connector_mode_valid,		.mode_valid = msm_hdmi_connector_mode_valid,
	.best_encoder = hdmi_connector_best_encoder,		.best_encoder = msm_hdmi_connector_best_encoder,
	};		};

	/* initialize connector */		/* initialize connector */
	struct drm_connector hdmi_connector_init(struct hdmi hdmi)		struct drm_connector msm_hdmi_connector_init(struct hdmi hdmi)
	{		{
	struct drm_connector *connector = NULL;		struct drm_connector *connector = NULL;
	struct hdmi_connector *hdmi_connector;		struct hdmi_connector *hdmi_connector;
	@@ -439,13 +439,13 @@ struct drm_connector hdmi_connector_init(struct hdmi hdmi)
	}		}

	hdmi_connector->hdmi = hdmi;		hdmi_connector->hdmi = hdmi;
	INIT_WORK(&hdmi_connector->hpd_work, hotplug_work);		INIT_WORK(&hdmi_connector->hpd_work, msm_hdmi_hotplug_work);

	connector = &hdmi_connector->base;		connector = &hdmi_connector->base;

	drm_connector_init(hdmi->dev, connector, &hdmi_connector_funcs,		drm_connector_init(hdmi->dev, connector, &hdmi_connector_funcs,
	DRM_MODE_CONNECTOR_HDMIA);		DRM_MODE_CONNECTOR_HDMIA);
	drm_connector_helper_add(connector, &hdmi_connector_helper_funcs);		drm_connector_helper_add(connector, &msm_hdmi_connector_helper_funcs);

	connector->polled = DRM_CONNECTOR_POLL_CONNECT \|		connector->polled = DRM_CONNECTOR_POLL_CONNECT \|
	DRM_CONNECTOR_POLL_DISCONNECT;		DRM_CONNECTOR_POLL_DISCONNECT;

Admin message