From mboxrd@z Thu Jan  1 00:00:00 1970
Return-Path: <linux-kernel-owner@vger.kernel.org>
Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand
	id S1755228AbbCRH43 (ORCPT <rfc822;w@1wt.eu>);
	Wed, 18 Mar 2015 03:56:29 -0400
Received: from smtp.codeaurora.org ([198.145.29.96]:55313 "EHLO
	smtp.codeaurora.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org
	with ESMTP id S1755061AbbCRH40 (ORCPT
	<rfc822;linux-kernel@vger.kernel.org>);
	Wed, 18 Mar 2015 03:56:26 -0400
Message-ID: <55092F9C.3050004@codeaurora.org>
Date: Wed, 18 Mar 2015 13:26:12 +0530
From: Archit Taneja <architt@codeaurora.org>
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:31.0) Gecko/20100101 Thunderbird/31.4.0
MIME-Version: 1.0
To: Hai Li <hali@codeaurora.org>
CC: dri-devel@lists.freedesktop.org, linux-arm-msm@vger.kernel.org,
        linux-kernel@vger.kernel.org
Subject: Re: [PATCH 3/4] drm/msm: Initial add DSI connector support
References: <1426289058-6663-1-git-send-email-hali@codeaurora.org> <1426289058-6663-4-git-send-email-hali@codeaurora.org>
In-Reply-To: <1426289058-6663-4-git-send-email-hali@codeaurora.org>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 7bit
Sender: linux-kernel-owner@vger.kernel.org
List-ID: <linux-kernel.vger.kernel.org>
X-Mailing-List: linux-kernel@vger.kernel.org

Hi,

On 03/14/2015 04:54 AM, Hai Li wrote:
> This change adds the DSI connector support in msm drm driver.
>
> Signed-off-by: Hai Li <hali@codeaurora.org>
> ---
>   drivers/gpu/drm/msm/Kconfig           |   11 +
>   drivers/gpu/drm/msm/Makefile          |    4 +
>   drivers/gpu/drm/msm/dsi/dsi.c         |  203 ++++
>   drivers/gpu/drm/msm/dsi/dsi.h         |  115 ++
>   drivers/gpu/drm/msm/dsi/dsi_host.c    | 1997 +++++++++++++++++++++++++++++++++
>   drivers/gpu/drm/msm/dsi/dsi_manager.c |  706 ++++++++++++
>   drivers/gpu/drm/msm/dsi/dsi_phy.c     |  352 ++++++
>   drivers/gpu/drm/msm/msm_drv.h         |   20 +
>   8 files changed, 3408 insertions(+)
>   create mode 100644 drivers/gpu/drm/msm/dsi/dsi.c
>   create mode 100644 drivers/gpu/drm/msm/dsi/dsi.h
>   create mode 100644 drivers/gpu/drm/msm/dsi/dsi_host.c
>   create mode 100644 drivers/gpu/drm/msm/dsi/dsi_manager.c
>   create mode 100644 drivers/gpu/drm/msm/dsi/dsi_phy.c
>
> diff --git a/drivers/gpu/drm/msm/Kconfig b/drivers/gpu/drm/msm/Kconfig
> index 1e6a907..5ba5631 100644
> --- a/drivers/gpu/drm/msm/Kconfig
> +++ b/drivers/gpu/drm/msm/Kconfig
> @@ -35,3 +35,14 @@ config DRM_MSM_REGISTER_LOGGING
>   	  Compile in support for logging register reads/writes in a format
>   	  that can be parsed by envytools demsm tool.  If enabled, register
>   	  logging can be switched on via msm.reglog=y module param.
> +
> +config DRM_MSM_DSI
> +	bool "Enable DSI support in MSM DRM driver"
> +	depends on DRM_MSM
> +	select DRM_PANEL
> +	select DRM_MIPI_DSI
> +	default y
> +	help
> +	  Choose this option if you have a need for MIPI DSI connector
> +	  support.
> +
> diff --git a/drivers/gpu/drm/msm/Makefile b/drivers/gpu/drm/msm/Makefile
> index 674a132..5c144cc 100644
> --- a/drivers/gpu/drm/msm/Makefile
> +++ b/drivers/gpu/drm/msm/Makefile
> @@ -50,5 +50,9 @@ msm-y := \
>
>   msm-$(CONFIG_DRM_MSM_FBDEV) += msm_fbdev.o
>   msm-$(CONFIG_COMMON_CLK) += mdp/mdp4/mdp4_lvds_pll.o
> +msm-$(CONFIG_DRM_MSM_DSI) += dsi/dsi.o \
> +			dsi/dsi_host.o \
> +			dsi/dsi_manager.o \
> +			dsi/dsi_phy.o
>
>   obj-$(CONFIG_DRM_MSM)	+= msm.o
> diff --git a/drivers/gpu/drm/msm/dsi/dsi.c b/drivers/gpu/drm/msm/dsi/dsi.c
> new file mode 100644
> index 0000000..de77260
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dsi/dsi.c
> @@ -0,0 +1,203 @@
> +/*
> + * Copyright (c) 2015, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + */
> +
> +#include "dsi.h"
> +
> +int msm_dsi_modeset_init(struct msm_drm_sub_dev *base, struct drm_device *dev)
> +{
> +	struct msm_dsi *msm_dsi = container_of(base, struct msm_dsi, base);
> +	struct msm_drm_private *priv = dev->dev_private;
> +	int ret, i;
> +
> +	if (WARN_ON((base->num_encoders != MSM_DSI_ENCODER_NUM) ||
> +		!base->encoders[MSM_DSI_VIDEO_ENCODER_ID] ||
> +		!base->encoders[MSM_DSI_CMD_ENCODER_ID]))
> +		return -EINVAL;
> +
> +	msm_dsi->dev = dev;
> +
> +	ret = msm_dsi_host_modeset_init(msm_dsi->host, dev);
> +	if (ret) {
> +		dev_err(dev->dev, "failed to modeset init host: %d\n", ret);
> +		goto fail;
> +	}
> +
> +	msm_dsi->bridge = msm_dsi_manager_bridge_init(msm_dsi->id);
> +	if (IS_ERR(msm_dsi->bridge)) {
> +		ret = PTR_ERR(msm_dsi->bridge);
> +		dev_err(dev->dev, "failed to create dsi bridge: %d\n", ret);
> +		msm_dsi->bridge = NULL;
> +		goto fail;
> +	}
> +
> +	msm_dsi->connector = msm_dsi_manager_connector_init(msm_dsi->id);
> +	if (IS_ERR(msm_dsi->connector)) {
> +		ret = PTR_ERR(msm_dsi->connector);
> +		dev_err(dev->dev, "failed to create dsi connector: %d\n", ret);
> +		msm_dsi->connector = NULL;
> +		goto fail;
> +	}
> +
> +	for (i = 0; i < base->num_encoders; i++)
> +		base->encoders[i]->bridge = msm_dsi->bridge;
> +
> +	priv->bridges[priv->num_bridges++]       = msm_dsi->bridge;
> +	priv->connectors[priv->num_connectors++] = msm_dsi->connector;
> +
> +	return 0;
> +fail:
> +	if (msm_dsi) {
> +		/* bridge/connector are normally destroyed by drm: */
> +		if (msm_dsi->bridge) {
> +			msm_dsi_manager_bridge_destroy(msm_dsi->bridge);
> +			msm_dsi->bridge = NULL;
> +		}
> +		if (msm_dsi->connector) {
> +			msm_dsi->connector->funcs->destroy(msm_dsi->connector);
> +			msm_dsi->connector = NULL;
> +		}
> +	}
> +
> +	return ret;
> +}
> +
> +static void dsi_destroy(struct msm_dsi *msm_dsi)
> +{
> +	if (!msm_dsi)
> +		return;
> +
> +	msm_dsi_manager_unregister(msm_dsi);
> +	if (msm_dsi->host) {
> +		msm_dsi_host_destroy(msm_dsi->host);
> +		msm_dsi->host = NULL;
> +	}
> +
> +	platform_set_drvdata(msm_dsi->pdev, NULL);
> +}
> +
> +static struct msm_dsi *dsi_init(struct platform_device *pdev)
> +{
> +	struct msm_dsi *msm_dsi = NULL;
> +	int ret;
> +
> +	if (!pdev) {
> +		dev_err(&pdev->dev, "no dsi device\n");
> +		ret = -ENXIO;
> +		goto fail;
> +	}
> +
> +	msm_dsi = devm_kzalloc(&pdev->dev, sizeof(*msm_dsi), GFP_KERNEL);
> +	if (!msm_dsi) {
> +		ret = -ENOMEM;
> +		goto fail;
> +	}
> +	DBG("dsi probed=%p", msm_dsi);
> +
> +	msm_dsi->pdev = pdev;
> +	platform_set_drvdata(pdev, msm_dsi);
> +
> +	/* Init dsi host */
> +	ret = msm_dsi_host_init(msm_dsi);
> +	if (ret)
> +		goto fail;
> +
> +	/* Register to dsi manager */
> +	ret = msm_dsi_manager_register(msm_dsi);
> +	if (ret)
> +		goto fail;
> +
> +	msm_dsi->base.modeset_init = msm_dsi_modeset_init;
> +
> +	return msm_dsi;
> +
> +fail:
> +	if (msm_dsi)
> +		dsi_destroy(msm_dsi);
> +
> +	return ERR_PTR(ret);
> +}
> +
> +static int dsi_bind(struct device *dev, struct device *master, void *data)
> +{
> +	struct drm_device *drm = dev_get_drvdata(master);
> +	struct msm_drm_private *priv = drm->dev_private;
> +	struct platform_device *pdev = to_platform_device(dev);
> +	struct msm_dsi *msm_dsi;
> +
> +	DBG("");
> +	msm_dsi = dsi_init(pdev);
> +	if (IS_ERR(msm_dsi))
> +		return PTR_ERR(msm_dsi);
> +
> +	priv->dsi[msm_dsi->id] = &msm_dsi->base;
> +
> +	return 0;
> +}
> +
> +static void dsi_unbind(struct device *dev, struct device *master,
> +		void *data)
> +{
> +	struct drm_device *drm = dev_get_drvdata(master);
> +	struct msm_drm_private *priv = drm->dev_private;
> +	struct msm_dsi *msm_dsi = dev_get_drvdata(dev);
> +	int id = msm_dsi->id;
> +
> +	if (priv->dsi[id]) {
> +		dsi_destroy(msm_dsi);
> +		priv->dsi[id] = NULL;
> +	}
> +}
> +
> +static const struct component_ops dsi_ops = {
> +	.bind   = dsi_bind,
> +	.unbind = dsi_unbind,
> +};
> +
> +static int dsi_dev_probe(struct platform_device *pdev)
> +{
> +	return component_add(&pdev->dev, &dsi_ops);
> +}
> +
> +static int dsi_dev_remove(struct platform_device *pdev)
> +{
> +	DBG("");
> +	component_del(&pdev->dev, &dsi_ops);
> +	return 0;
> +}
> +
> +static const struct of_device_id dt_match[] = {
> +	{ .compatible = "qcom,mdss-dsi-ctrl" },
> +	{}
> +};
> +
> +static struct platform_driver dsi_driver = {
> +	.probe = dsi_dev_probe,
> +	.remove = dsi_dev_remove,
> +	.driver = {
> +		.name = "msm_dsi",
> +		.of_match_table = dt_match,
> +	},
> +};
> +
> +void __init msm_dsi_register(void)
> +{
> +	DBG("");
> +	platform_driver_register(&dsi_driver);
> +}
> +
> +void __exit msm_dsi_unregister(void)
> +{
> +	DBG("");
> +	platform_driver_unregister(&dsi_driver);
> +}
> +
> diff --git a/drivers/gpu/drm/msm/dsi/dsi.h b/drivers/gpu/drm/msm/dsi/dsi.h
> new file mode 100644
> index 0000000..1d24409
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dsi/dsi.h
> @@ -0,0 +1,115 @@
> +/*
> + * Copyright (c) 2015, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + */
> +
> +#ifndef __DSI_CONNECTOR_H__
> +#define __DSI_CONNECTOR_H__
> +
> +#include <linux/platform_device.h>
> +
> +#include "drm_crtc.h"
> +#include "drm_mipi_dsi.h"
> +#include "drm_panel.h"
> +
> +#include "msm_drv.h"
> +
> +#define DSI_0	0
> +#define DSI_1	1
> +#define DSI_MAX	2
> +
> +#define DSI_CLOCK_MASTER	DSI_0
> +#define DSI_CLOCK_SLAVE		DSI_1
> +
> +#define DSI_LEFT		DSI_0
> +#define DSI_RIGHT		DSI_1
> +
> +/* According to the current drm framework sequence, take the encoder of
> + * DSI_1 as master encoder
> + */
> +#define DSI_ENCODER_MASTER	DSI_1
> +#define DSI_ENCODER_SLAVE	DSI_0
> +
> +struct msm_dsi {
> +	struct msm_drm_sub_dev base;
> +	struct drm_device *dev;
> +	struct platform_device *pdev;
> +
> +	struct drm_connector *connector;
> +	struct drm_bridge *bridge;
> +
> +	struct mipi_dsi_host *host;
> +	struct msm_dsi_phy *phy;
> +	struct drm_panel *panel;
> +	unsigned long panel_flags;
> +	bool phy_enabled;
> +
> +	/* the encoder we are hooked to (outside of dsi block) */
> +	struct drm_encoder *encoder;
> +
> +	int id;
> +};
> +
> +/* dsi manager */
> +struct drm_bridge *msm_dsi_manager_bridge_init(u8 id);
> +void msm_dsi_manager_bridge_destroy(struct drm_bridge *bridge);
> +struct drm_connector *msm_dsi_manager_connector_init(u8 id);
> +int msm_dsi_manager_phy_enable(int id,
> +		const unsigned long bit_rate, const unsigned long esc_rate,
> +		u32 *clk_pre, u32 *clk_post);
> +void msm_dsi_manager_phy_disable(int id);
> +int msm_dsi_manager_cmd_xfer(int id, const struct mipi_dsi_msg *msg);
> +bool msm_dsi_manager_cmd_xfer_trigger(int id, u32 iova, u32 len);
> +int msm_dsi_manager_register(struct msm_dsi *msm_dsi);
> +void msm_dsi_manager_unregister(struct msm_dsi *msm_dsi);
> +
> +/* dsi host */
> +int msm_dsi_host_xfer_prepare(struct mipi_dsi_host *host,
> +					const struct mipi_dsi_msg *msg);
> +void msm_dsi_host_xfer_restore(struct mipi_dsi_host *host,
> +					const struct mipi_dsi_msg *msg);
> +int msm_dsi_host_cmd_tx(struct mipi_dsi_host *host,
> +					const struct mipi_dsi_msg *msg);
> +int msm_dsi_host_cmd_rx(struct mipi_dsi_host *host,
> +					const struct mipi_dsi_msg *msg);
> +void msm_dsi_host_cmd_xfer_commit(struct mipi_dsi_host *host,
> +					u32 iova, u32 len);
> +int msm_dsi_host_enable(struct mipi_dsi_host *host);
> +int msm_dsi_host_disable(struct mipi_dsi_host *host);
> +int msm_dsi_host_power_on(struct mipi_dsi_host *host);
> +int msm_dsi_host_power_off(struct mipi_dsi_host *host);
> +int msm_dsi_host_set_display_mode(struct mipi_dsi_host *host,
> +					struct drm_display_mode *mode);
> +struct drm_panel *msm_dsi_host_get_panel(struct mipi_dsi_host *host,
> +					unsigned long *panel_flags);
> +int msm_dsi_host_register(struct mipi_dsi_host *host, bool check_defer);
> +void msm_dsi_host_unregister(struct mipi_dsi_host *host);
> +void msm_dsi_host_destroy(struct mipi_dsi_host *host);
> +int msm_dsi_host_modeset_init(struct mipi_dsi_host *host,
> +					struct drm_device *dev);
> +int msm_dsi_host_init(struct msm_dsi *msm_dsi);
> +
> +/* dsi phy */
> +struct msm_dsi_phy;
> +enum msm_dsi_phy_type {
> +	MSM_DSI_PHY_UNKNOWN,
> +	MSM_DSI_PHY_28NM,
> +	MSM_DSI_PHY_MAX
> +};
> +struct msm_dsi_phy *msm_dsi_phy_init(struct platform_device *pdev,
> +			enum msm_dsi_phy_type type, int id);
> +int msm_dsi_phy_enable(struct msm_dsi_phy *phy, bool is_dual_panel,
> +	const unsigned long bit_rate, const unsigned long esc_rate);
> +int msm_dsi_phy_disable(struct msm_dsi_phy *phy);
> +void msm_dsi_phy_get_clk_pre_post(struct msm_dsi_phy *phy,
> +					u32 *clk_pre, u32 *clk_post);
> +#endif /* __DSI_CONNECTOR_H__ */
> +
> diff --git a/drivers/gpu/drm/msm/dsi/dsi_host.c b/drivers/gpu/drm/msm/dsi/dsi_host.c
> new file mode 100644
> index 0000000..8db11eb
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dsi/dsi_host.c
> @@ -0,0 +1,1997 @@
> +/*
> + * Copyright (c) 2015, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + */
> +
> +#include <linux/clk.h>
> +#include <linux/delay.h>
> +#include <linux/err.h>
> +#include <linux/gpio.h>
> +#include <linux/interrupt.h>
> +#include <linux/of_device.h>
> +#include <linux/of_gpio.h>
> +#include <linux/of_irq.h>
> +#include <linux/regulator/consumer.h>
> +#include <linux/spinlock.h>
> +#include <video/mipi_display.h>
> +
> +#include "dsi.h"
> +#include "dsi.xml.h"
> +
> +#define MSM_DSI_VER_MAJOR_V2	0x02
> +#define MSM_DSI_VER_MAJOR_6G	0x03
> +#define MSM_DSI_6G_VER_MINOR_V1_0	0x10000000
> +#define MSM_DSI_6G_VER_MINOR_V1_1	0x10010000
> +#define MSM_DSI_6G_VER_MINOR_V1_1_1	0x10010001
> +#define MSM_DSI_6G_VER_MINOR_V1_2	0x10020000
> +#define MSM_DSI_6G_VER_MINOR_V1_3_1	0x10030001
> +
> +#define DSI_6G_REG_SHIFT	4
> +
> +#define DSI_REGULATOR_MAX	8
> +struct dsi_reg_entry {
> +	char name[32];
> +	int min_voltage;
> +	int max_voltage;
> +	int enable_load;
> +	int disable_load;
> +};
> +
> +struct dsi_reg_config {
> +	int num;
> +	struct dsi_reg_entry regs[DSI_REGULATOR_MAX];
> +};
> +
> +struct dsi_config {
> +	u32 major;
> +	u32 minor;
> +	u32 io_offset;
> +	enum msm_dsi_phy_type phy_type;
> +	struct dsi_reg_config reg_cfg;
> +};
> +
> +static const struct dsi_config dsi_cfgs[] = {
> +	{MSM_DSI_VER_MAJOR_V2, 0, 0, MSM_DSI_PHY_UNKNOWN},
> +	{ /* 8974 v1 */
> +		.major = MSM_DSI_VER_MAJOR_6G,
> +		.minor = MSM_DSI_6G_VER_MINOR_V1_0,
> +		.io_offset = DSI_6G_REG_SHIFT,
> +		.phy_type = MSM_DSI_PHY_28NM,
> +		.reg_cfg = {
> +			.num = 4,
> +			.regs = {
> +				{"gdsc", -1, -1, -1, -1},
> +				{"vdd", 3000000, 3000000, 150000, 100},
> +				{"vdda", 1200000, 1200000, 100000, 100},
> +				{"vddio", 1800000, 1800000, 100000, 100},
> +			},
> +		},
> +	},
> +	{ /* 8974 v2 */
> +		.major = MSM_DSI_VER_MAJOR_6G,
> +		.minor = MSM_DSI_6G_VER_MINOR_V1_1,
> +		.io_offset = DSI_6G_REG_SHIFT,
> +		.phy_type = MSM_DSI_PHY_28NM,
> +		.reg_cfg = {
> +			.num = 4,
> +			.regs = {
> +				{"gdsc", -1, -1, -1, -1},
> +				{"vdd", 3000000, 3000000, 150000, 100},
> +				{"vdda", 1200000, 1200000, 100000, 100},
> +				{"vddio", 1800000, 1800000, 100000, 100},
> +			},
> +		},
> +	},
> +	{ /* 8974 v3 */
> +		.major = MSM_DSI_VER_MAJOR_6G,
> +		.minor = MSM_DSI_6G_VER_MINOR_V1_1_1,
> +		.io_offset = DSI_6G_REG_SHIFT,
> +		.phy_type = MSM_DSI_PHY_28NM,
> +		.reg_cfg = {
> +			.num = 4,
> +			.regs = {
> +				{"gdsc", -1, -1, -1, -1},
> +				{"vdd", 3000000, 3000000, 150000, 100},
> +				{"vdda", 1200000, 1200000, 100000, 100},
> +				{"vddio", 1800000, 1800000, 100000, 100},
> +			},
> +		},
> +	},
> +	{ /* 8084 */
> +		.major = MSM_DSI_VER_MAJOR_6G,
> +		.minor = MSM_DSI_6G_VER_MINOR_V1_2,
> +		.io_offset = DSI_6G_REG_SHIFT,
> +		.phy_type = MSM_DSI_PHY_28NM,
> +		.reg_cfg = {
> +			.num = 4,
> +			.regs = {
> +				{"gdsc", -1, -1, -1, -1},
> +				{"vdd", 3000000, 3000000, 150000, 100},
> +				{"vdda", 1200000, 1200000, 100000, 100},
> +				{"vddio", 1800000, 1800000, 100000, 100},
> +			},
> +		},
> +	},
> +	{ /* 8916 */
> +		.major = MSM_DSI_VER_MAJOR_6G,
> +		.minor = MSM_DSI_6G_VER_MINOR_V1_3_1,
> +		.io_offset = DSI_6G_REG_SHIFT,
> +		.phy_type = MSM_DSI_PHY_28NM,
> +		.reg_cfg = {
> +			.num = 4,
> +			.regs = {
> +				{"gdsc", -1, -1, -1, -1},
> +				{"vdd", 2850000, 2850000, 100000, 100},
> +				{"vdda", 1200000, 1200000, 100000, 100},
> +				{"vddio", 1800000, 1800000, 100000, 100},
> +			},
> +		},
> +	},
> +};
> +
> +static int dsi_get_version(const void __iomem *base, u32 *major, u32 *minor)
> +{
> +	u32 ver;
> +	u32 ver_6g;
> +
> +	if (!major || !minor)
> +		return -EINVAL;
> +
> +	/* From DSI6G(v3), addition of a 6G_HW_VERSION register at offset 0
> +	 * makes all other registers 4-byte shifted down.
> +	 */
> +	ver_6g = msm_readl(base + REG_DSI_6G_HW_VERSION);
> +	if (ver_6g == 0) {
> +		ver = msm_readl(base + REG_DSI_VERSION);
> +		ver = FIELD(ver, DSI_VERSION_MAJOR);
> +		if (ver <= MSM_DSI_VER_MAJOR_V2) {
> +			/* old versions */
> +			*major = ver;
> +			*minor = 0;
> +			return 0;
> +		} else {
> +			return -EINVAL;
> +		}
> +	} else {
> +		ver = msm_readl(base + DSI_6G_REG_SHIFT + REG_DSI_VERSION);
> +		ver = FIELD(ver, DSI_VERSION_MAJOR);
> +		if (ver == MSM_DSI_VER_MAJOR_6G) {
> +			/* 6G version */
> +			*major = ver;
> +			*minor = ver_6g;
> +			return 0;
> +		} else {
> +			return -EINVAL;
> +		}
> +	}
> +}
> +
> +#define DSI_ERR_STATE_ACK			0x0000
> +#define DSI_ERR_STATE_TIMEOUT			0x0001
> +#define DSI_ERR_STATE_DLN0_PHY			0x0002
> +#define DSI_ERR_STATE_FIFO			0x0004
> +#define DSI_ERR_STATE_MDP_FIFO_UNDERFLOW	0x0008
> +#define DSI_ERR_STATE_INTERLEAVE_OP_CONTENTION	0x0010
> +#define DSI_ERR_STATE_PLL_UNLOCKED		0x0020
> +
> +struct msm_dsi_host {
> +	struct mipi_dsi_host base;
> +
> +	struct platform_device *pdev;
> +	struct drm_device *dev;
> +
> +	int id;
> +
> +	void __iomem *ctrl_base;
> +	struct regulator_bulk_data supplies[DSI_REGULATOR_MAX];
> +	struct clk *mdp_core_clk;
> +	struct clk *ahb_clk;
> +	struct clk *axi_clk;
> +	struct clk *mmss_misc_ahb_clk;
> +	struct clk *byte_clk;
> +	struct clk *esc_clk;
> +	struct clk *pixel_clk;
> +	u32 byte_clk_rate;
> +
> +	struct gpio_desc *disp_en_gpio;
> +	struct gpio_desc *te_gpio;
> +
> +	const struct dsi_config *cfg;
> +
> +	struct completion dma_comp;
> +	struct completion video_comp;
> +	struct mutex dev_mutex;
> +	struct mutex cmd_mutex;
> +	struct mutex clk_mutex;
> +	spinlock_t intr_lock; /* Protect interrupt ctrl register */
> +
> +	u32 err_work_state;
> +	struct work_struct err_work;
> +	struct workqueue_struct *workqueue;
> +
> +	struct drm_gem_object *tx_gem_obj;
> +	u8 *rx_buf;
> +
> +	struct drm_display_mode *mode;
> +
> +	/* Panel info */
> +	struct device_node *panel_node;
> +	unsigned int channel;
> +	unsigned int lanes;
> +	enum mipi_dsi_pixel_format format;
> +	unsigned long mode_flags;
> +
> +	u32 dma_cmd_ctrl_restore;
> +
> +	bool registered;
> +	bool power_on;
> +	int irq;
> +};
> +
> +static u32 dsi_get_bpp(const enum mipi_dsi_pixel_format fmt)
> +{
> +	switch (fmt) {
> +	case MIPI_DSI_FMT_RGB565:		return 16;
> +	case MIPI_DSI_FMT_RGB666_PACKED:	return 18;
> +	case MIPI_DSI_FMT_RGB666:
> +	case MIPI_DSI_FMT_RGB888:
> +	default:				return 24;
> +	}
> +}
> +
> +static inline u32 dsi_read(struct msm_dsi_host *msm_host, u32 reg)
> +{
> +	return msm_readl(msm_host->ctrl_base + msm_host->cfg->io_offset + reg);
> +}
> +static inline void dsi_write(struct msm_dsi_host *msm_host, u32 reg, u32 data)
> +{
> +	msm_writel(data, msm_host->ctrl_base + msm_host->cfg->io_offset + reg);
> +}
> +
> +static int dsi_host_regulator_enable(struct msm_dsi_host *msm_host);
> +static void dsi_host_regulator_disable(struct msm_dsi_host *msm_host);
> +
> +static const struct dsi_config *dsi_get_config(struct msm_dsi_host *msm_host)
> +{
> +	const struct dsi_config *cfg;
> +	struct regulator *gdsc_reg;
> +	int i, ret;
> +	u32 major, minor;
> +
> +	gdsc_reg = regulator_get(&msm_host->pdev->dev, "gdsc");
> +	if (IS_ERR_OR_NULL(gdsc_reg)) {
> +		pr_err("%s: cannot get gdsc\n", __func__);
> +		goto fail;
> +	}
> +	ret = regulator_enable(gdsc_reg);
> +	if (ret) {
> +		pr_err("%s: unable to enable gdsc\n", __func__);
> +		regulator_put(gdsc_reg);
> +		goto fail;
> +	}
> +	ret = clk_prepare_enable(msm_host->ahb_clk);
> +	if (ret) {
> +		pr_err("%s: unable to enable ahb_clk\n", __func__);
> +		regulator_disable(gdsc_reg);
> +		regulator_put(gdsc_reg);
> +		goto fail;
> +	}
> +
> +	ret = dsi_get_version(msm_host->ctrl_base, &major, &minor);
> +
> +	clk_disable_unprepare(msm_host->ahb_clk);
> +	regulator_disable(gdsc_reg);
> +	regulator_put(gdsc_reg);
> +	if (ret) {
> +		pr_err("%s: Invalid version\n", __func__);
> +		goto fail;
> +	}
> +
> +	for (i = 0; i < ARRAY_SIZE(dsi_cfgs); i++) {
> +		cfg = dsi_cfgs + i;
> +		if ((cfg->major == major) && (cfg->minor == minor))
> +			return cfg;
> +	}
> +	pr_err("%s: Version %x:%x not support\n", __func__, major, minor);
> +
> +fail:
> +	return NULL;
> +}
> +
> +static inline struct msm_dsi_host *to_msm_dsi_host(struct mipi_dsi_host *host)
> +{
> +	return container_of(host, struct msm_dsi_host, base);
> +}
> +
> +static void dsi_host_regulator_disable(struct msm_dsi_host *msm_host)
> +{
> +	struct regulator_bulk_data *s = msm_host->supplies;
> +	const struct dsi_reg_entry *regs = msm_host->cfg->reg_cfg.regs;
> +	int num = msm_host->cfg->reg_cfg.num;
> +	int i;
> +
> +	DBG("");
> +	for (i = num - 1; i >= 0; i--)
> +		if (regs[i].disable_load >= 0)
> +			regulator_set_optimum_mode(s[i].consumer,
> +						regs[i].disable_load);
> +
> +	regulator_bulk_disable(num, s);
> +}
> +
> +static int dsi_host_regulator_enable(struct msm_dsi_host *msm_host)
> +{
> +	struct regulator_bulk_data *s = msm_host->supplies;
> +	const struct dsi_reg_entry *regs = msm_host->cfg->reg_cfg.regs;
> +	int num = msm_host->cfg->reg_cfg.num;
> +	int ret, i;
> +
> +	DBG("");
> +	for (i = 0; i < num; i++) {
> +		if (regs[i].enable_load >= 0) {
> +			ret = regulator_set_optimum_mode(s[i].consumer,
> +							regs[i].enable_load);
> +			if (ret < 0) {
> +				pr_err("regulator %d set op mode failed, %d\n",
> +					i, ret);
> +				goto fail;
> +			}
> +		}
> +	}
> +
> +	ret = regulator_bulk_enable(num, s);
> +	if (ret < 0) {
> +		pr_err("regulator enable failed, %d\n", ret);
> +		goto fail;
> +	}
> +
> +	return 0;
> +
> +fail:
> +	for (i--; i >= 0; i--)
> +		regulator_set_optimum_mode(s[i].consumer, regs[i].disable_load);
> +	return ret;
> +}
> +
> +static int dsi_regulator_init(struct msm_dsi_host *msm_host)
> +{
> +	struct regulator_bulk_data *s = msm_host->supplies;
> +	const struct dsi_reg_entry *regs = msm_host->cfg->reg_cfg.regs;
> +	int num = msm_host->cfg->reg_cfg.num;
> +	int i, ret;
> +
> +	for (i = 0; i < num; i++)
> +		s[i].supply = regs[i].name;
> +
> +	ret = devm_regulator_bulk_get(&msm_host->pdev->dev, num, s);
> +	if (ret < 0) {
> +		pr_err("%s: failed to init regulator, ret=%d\n",
> +						__func__, ret);
> +		return ret;
> +	}
> +
> +	for (i = 0; i < num; i++) {
> +		if ((regs[i].min_voltage >= 0) && (regs[i].max_voltage >= 0)) {
> +			ret = regulator_set_voltage(s[i].consumer,
> +				regs[i].min_voltage, regs[i].max_voltage);
> +			if (ret < 0) {
> +				pr_err("regulator %d set voltage failed, %d\n",
> +					i, ret);
> +				return ret;
> +			}
> +		}
> +	}
> +
> +	return 0;
> +}
> +
> +static int dsi_clk_init(struct msm_dsi_host *msm_host)
> +{
> +	struct device *dev = &msm_host->pdev->dev;
> +	int ret = 0;
> +
> +	msm_host->mdp_core_clk = devm_clk_get(dev, "mdp_core_clk");
> +	if (IS_ERR(msm_host->mdp_core_clk)) {
> +		ret = PTR_ERR(msm_host->mdp_core_clk);
> +		pr_err("%s: Unable to get mdp core clk. ret=%d\n",
> +			__func__, ret);
> +		goto exit;
> +	}
> +
> +	msm_host->ahb_clk = devm_clk_get(dev, "iface_clk");
> +	if (IS_ERR(msm_host->ahb_clk)) {
> +		ret = PTR_ERR(msm_host->ahb_clk);
> +		pr_err("%s: Unable to get mdss ahb clk. ret=%d\n",
> +			__func__, ret);
> +		goto exit;
> +	}
> +
> +	msm_host->axi_clk = devm_clk_get(dev, "bus_clk");
> +	if (IS_ERR(msm_host->axi_clk)) {
> +		ret = PTR_ERR(msm_host->axi_clk);
> +		pr_err("%s: Unable to get axi bus clk. ret=%d\n",
> +			__func__, ret);
> +		goto exit;
> +	}
> +
> +	msm_host->mmss_misc_ahb_clk = devm_clk_get(dev, "core_mmss_clk");
> +	if (IS_ERR(msm_host->mmss_misc_ahb_clk)) {
> +		ret = PTR_ERR(msm_host->mmss_misc_ahb_clk);
> +		pr_err("%s: Unable to get mmss misc ahb clk. ret=%d\n",
> +			__func__, ret);
> +		goto exit;
> +	}
> +
> +	msm_host->byte_clk = devm_clk_get(dev, "byte_clk");
> +	if (IS_ERR(msm_host->byte_clk)) {
> +		ret = PTR_ERR(msm_host->byte_clk);
> +		pr_err("%s: can't find dsi_byte_clk. ret=%d\n",
> +			__func__, ret);
> +		msm_host->byte_clk = NULL;
> +		goto exit;
> +	}
> +
> +	msm_host->pixel_clk = devm_clk_get(dev, "pixel_clk");
> +	if (IS_ERR(msm_host->pixel_clk)) {
> +		ret = PTR_ERR(msm_host->pixel_clk);
> +		pr_err("%s: can't find dsi_pixel_clk. ret=%d\n",
> +			__func__, ret);
> +		msm_host->pixel_clk = NULL;
> +		goto exit;
> +	}
> +
> +	msm_host->esc_clk = devm_clk_get(dev, "core_clk");
> +	if (IS_ERR(msm_host->esc_clk)) {
> +		ret = PTR_ERR(msm_host->esc_clk);
> +		pr_err("%s: can't find dsi_esc_clk. ret=%d\n",
> +			__func__, ret);
> +		msm_host->esc_clk = NULL;
> +		goto exit;
> +	}
> +
> +exit:
> +	return ret;
> +}
> +
> +static int dsi_bus_clk_enable(struct msm_dsi_host *msm_host)
> +{
> +	int ret = 0;
> +
> +	DBG("%s: id=%d\n", __func__, msm_host->id);
> +
> +	ret = clk_prepare_enable(msm_host->mdp_core_clk);
> +	if (ret) {
> +		pr_err("%s: failed to enable mdp_core_clock, %d\n",
> +							 __func__, ret);
> +		goto core_clk_err;
> +	}
> +
> +	ret = clk_prepare_enable(msm_host->ahb_clk);
> +	if (ret) {
> +		pr_err("%s: failed to enable ahb clock, %d\n", __func__, ret);
> +		goto ahb_clk_err;
> +	}
> +
> +	ret = clk_prepare_enable(msm_host->axi_clk);
> +	if (ret) {
> +		pr_err("%s: failed to enable ahb clock, %d\n", __func__, ret);
> +		goto axi_clk_err;
> +	}
> +
> +	ret = clk_prepare_enable(msm_host->mmss_misc_ahb_clk);
> +	if (ret) {
> +		pr_err("%s: failed to enable mmss misc ahb clk, %d\n",
> +			__func__, ret);
> +		goto misc_ahb_clk_err;
> +	}
> +
> +	return 0;
> +
> +misc_ahb_clk_err:
> +	clk_disable_unprepare(msm_host->axi_clk);
> +axi_clk_err:
> +	clk_disable_unprepare(msm_host->ahb_clk);
> +ahb_clk_err:
> +	clk_disable_unprepare(msm_host->mdp_core_clk);
> +core_clk_err:
> +	return ret;
> +}
> +
> +static void dsi_bus_clk_disable(struct msm_dsi_host *msm_host)
> +{
> +	DBG("");
> +	clk_disable_unprepare(msm_host->mmss_misc_ahb_clk);
> +	clk_disable_unprepare(msm_host->axi_clk);
> +	clk_disable_unprepare(msm_host->ahb_clk);
> +	clk_disable_unprepare(msm_host->mdp_core_clk);
> +}
> +
> +static int dsi_link_clk_enable(struct msm_dsi_host *msm_host)
> +{
> +	int ret = 0;
> +
> +	DBG("Set clk rates: pclk=%d, byteclk=%d\n",
> +		msm_host->mode->clock, msm_host->byte_clk_rate);
> +
> +	ret =  clk_set_rate(msm_host->byte_clk, msm_host->byte_clk_rate);
> +	if (ret) {
> +		pr_err("%s: Failed to set rate byte clk, %d\n", __func__, ret);
> +		goto error;
> +	}
> +
> +	ret = clk_set_rate(msm_host->pixel_clk, msm_host->mode->clock * 1000);
> +	if (ret) {
> +		pr_err("%s: Failed to set rate pixel clk, %d\n", __func__, ret);
> +		goto error;
> +	}
> +
> +	ret = clk_prepare_enable(msm_host->esc_clk);
> +	if (ret) {
> +		pr_err("%s: Failed to enable dsi esc clk\n", __func__);
> +		goto error;
> +	}
> +
> +	ret = clk_prepare_enable(msm_host->byte_clk);
> +	if (ret) {
> +		pr_err("%s: Failed to enable dsi byte clk\n", __func__);
> +		goto byte_clk_err;
> +	}
> +
> +	ret = clk_prepare_enable(msm_host->pixel_clk);
> +	if (ret) {
> +		pr_err("%s: Failed to enable dsi pixel clk\n", __func__);
> +		goto pixel_clk_err;
> +	}
> +
> +	return ret;
> +
> +pixel_clk_err:
> +	clk_disable_unprepare(msm_host->byte_clk);
> +byte_clk_err:
> +	clk_disable_unprepare(msm_host->esc_clk);
> +error:
> +	return ret;
> +}
> +
> +static void dsi_link_clk_disable(struct msm_dsi_host *msm_host)
> +{
> +	clk_disable_unprepare(msm_host->esc_clk);
> +	clk_disable_unprepare(msm_host->pixel_clk);
> +	clk_disable_unprepare(msm_host->byte_clk);
> +}
> +
> +static int dsi_clk_ctrl(struct msm_dsi_host *msm_host, bool enable)
> +{
> +	int ret;
> +
> +	mutex_lock(&msm_host->clk_mutex);
> +	if (enable) {
> +		ret = dsi_bus_clk_enable(msm_host);
> +		if (ret) {
> +			pr_err("%s: Can not enable bus clk, %d\n",
> +				__func__, ret);
> +			goto unlock_ret;
> +		}
> +		ret = dsi_link_clk_enable(msm_host);
> +		if (ret) {
> +			pr_err("%s: Can not enable link clk, %d\n",
> +				__func__, ret);
> +			dsi_bus_clk_disable(msm_host);
> +			goto unlock_ret;
> +		}
> +	} else {
> +		dsi_link_clk_disable(msm_host);
> +		dsi_bus_clk_disable(msm_host);
> +	}
> +
> +unlock_ret:
> +	mutex_unlock(&msm_host->clk_mutex);
> +	return 0;
> +}
> +
> +static int dsi_gpio_init(struct msm_dsi_host *msm_host)
> +{
> +	int ret;
> +
> +	msm_host->disp_en_gpio = devm_gpiod_get(&msm_host->pdev->dev,
> +						"disp-enable");
> +	if (IS_ERR(msm_host->disp_en_gpio)) {
> +		pr_warn("%s: cannot get disp-enable-gpios %ld\n",
> +			__func__, PTR_ERR(msm_host->disp_en_gpio));
> +		msm_host->disp_en_gpio = NULL;
> +	}
> +	if (msm_host->disp_en_gpio) {
> +		ret = gpiod_direction_output(msm_host->disp_en_gpio, 0);
> +		if (ret) {
> +			pr_err("cannot set dir to disp-en-gpios %d\n", ret);
> +			return ret;
> +		}
> +	}
> +
> +	msm_host->te_gpio = devm_gpiod_get(&msm_host->pdev->dev, "disp-te");
> +	if (IS_ERR(msm_host->te_gpio)) {
> +		pr_warn("%s: cannot get disp-te-gpios %ld\n",
> +			__func__, PTR_ERR(msm_host->te_gpio));

Video mode panels won't have te_gpio, we could probably make this pr_debug()

> +		msm_host->te_gpio = NULL;
> +	}
> +
> +	if (msm_host->te_gpio) {
> +		ret = gpiod_direction_input(msm_host->te_gpio);
> +		if (ret) {
> +			pr_err("%s: cannot set dir to disp-te-gpios, %d\n",
> +				__func__, ret);
> +			return ret;
> +		}
> +	}

These gpios currently need to be declared under the dsi DT node. Even if 
these are controlled via the dsi host, the gpios should still come under 
the panel DT node.

We shout get the panel's of_node here and look for these.

> +
> +	return ret;
> +}
> +
> +static int dsi_calc_clk_rate(struct msm_dsi_host *msm_host)
> +{
> +	struct drm_display_mode *mode = msm_host->mode;
> +	u8 lanes = msm_host->lanes;
> +	u32 bpp = dsi_get_bpp(msm_host->format);
> +	u32 pclk_rate;
> +
> +	if (!mode) {
> +		pr_err("%s: mode not set\n", __func__);
> +		return -EINVAL;
> +	}
> +
> +	pclk_rate = mode->clock * 1000;
> +	if (lanes > 0) {
> +		msm_host->byte_clk_rate = (pclk_rate * bpp) / (8 * lanes);
> +	} else {
> +		pr_err("%s: forcing mdss_dsi lanes to 1\n", __func__);
> +		msm_host->byte_clk_rate = (pclk_rate * bpp) / 8;
> +	}
> +
> +	DBG("pclk=%d, bclk=%d\n", pclk_rate, msm_host->byte_clk_rate);
> +
> +	return 0;
> +}
> +
> +static void dsi_phy_sw_reset(struct msm_dsi_host *msm_host)
> +{
> +	DBG("");
> +	dsi_write(msm_host, REG_DSI_PHY_RESET, DSI_PHY_RESET_RESET);
> +	/* Make sure fully reset */
> +	wmb();
> +	udelay(1000);
> +	dsi_write(msm_host, REG_DSI_PHY_RESET, 0);
> +	udelay(100);
> +}
> +
> +static void dsi_intr_ctrl(struct msm_dsi_host *msm_host, u32 mask, int enable)
> +{
> +	u32 intr;
> +	unsigned long flags;
> +
> +	spin_lock_irqsave(&msm_host->intr_lock, flags);
> +	intr = dsi_read(msm_host, REG_DSI_INTR_CTRL);
> +
> +	if (enable)
> +		intr |= mask;
> +	else
> +		intr &= ~mask;
> +
> +	DBG("intr=%x enable=%d", intr, enable);
> +
> +	dsi_write(msm_host, REG_DSI_INTR_CTRL, intr);
> +	spin_unlock_irqrestore(&msm_host->intr_lock, flags);
> +}
> +
> +static inline enum dsi_traffic_mode dsi_get_traffic_mode(const u32 mode_flags)
> +{
> +	if (mode_flags & MIPI_DSI_MODE_VIDEO_BURST)
> +		return BURST_MODE;
> +	else if (mode_flags & MIPI_DSI_MODE_VIDEO_SYNC_PULSE)
> +		return NON_BURST_SYNCH_PULSE;
> +
> +	return NON_BURST_SYNCH_EVENT;
> +}
> +
> +static inline enum dsi_vid_dst_format dsi_get_vid_fmt(
> +				const enum mipi_dsi_pixel_format mipi_fmt)
> +{
> +	switch (mipi_fmt) {
> +	case MIPI_DSI_FMT_RGB888:	return VID_DST_FORMAT_RGB888;
> +	case MIPI_DSI_FMT_RGB666:	return VID_DST_FORMAT_RGB666_LOOSE;
> +	case MIPI_DSI_FMT_RGB666_PACKED:	return VID_DST_FORMAT_RGB666;
> +	case MIPI_DSI_FMT_RGB565:	return VID_DST_FORMAT_RGB565;
> +	default:			return VID_DST_FORMAT_RGB888;
> +	}
> +}
> +
> +static inline enum dsi_cmd_dst_format dsi_get_cmd_fmt(
> +				const enum mipi_dsi_pixel_format mipi_fmt)
> +{
> +	switch (mipi_fmt) {
> +	case MIPI_DSI_FMT_RGB888:	return CMD_DST_FORMAT_RGB888;
> +	case MIPI_DSI_FMT_RGB666_PACKED:
> +	case MIPI_DSI_FMT_RGB666:	return VID_DST_FORMAT_RGB666;
> +	case MIPI_DSI_FMT_RGB565:	return CMD_DST_FORMAT_RGB565;
> +	default:			return CMD_DST_FORMAT_RGB888;
> +	}
> +}
> +
> +static void dsi_ctrl_config(struct msm_dsi_host *msm_host, bool enable,
> +				u32 clk_pre, u32 clk_post)
> +{
> +	u32 flags = msm_host->mode_flags;
> +	enum mipi_dsi_pixel_format mipi_fmt = msm_host->format;
> +	u32 data = 0;
> +
> +	if (!enable) {
> +		dsi_write(msm_host, REG_DSI_CTRL, 0);
> +		return;
> +	}
> +
> +	if (flags & MIPI_DSI_MODE_VIDEO) {
> +		if (flags & MIPI_DSI_MODE_VIDEO_HSE)
> +			data |= DSI_VID_CFG0_PULSE_MODE_HSA_HE;
> +		if (flags & MIPI_DSI_MODE_VIDEO_HFP)
> +			data |= DSI_VID_CFG0_HFP_POWER_STOP;
> +		if (flags & MIPI_DSI_MODE_VIDEO_HBP)
> +			data |= DSI_VID_CFG0_HBP_POWER_STOP;
> +		if (flags & MIPI_DSI_MODE_VIDEO_HSA)
> +			data |= DSI_VID_CFG0_HSA_POWER_STOP;
> +		/* Always set low power stop mode for BLLP
> +		 * to let command engine send packets
> +		 */
> +		data |= DSI_VID_CFG0_EOF_BLLP_POWER_STOP |
> +			DSI_VID_CFG0_BLLP_POWER_STOP;
> +		data |= DSI_VID_CFG0_TRAFFIC_MODE(dsi_get_traffic_mode(flags));
> +		data |= DSI_VID_CFG0_DST_FORMAT(dsi_get_vid_fmt(mipi_fmt));
> +		data |= DSI_VID_CFG0_VIRT_CHANNEL(msm_host->channel);
> +		dsi_write(msm_host, REG_DSI_VID_CFG0, data);
> +
> +		/* Do not swap RGB colors */
> +		data = DSI_VID_CFG1_RGB_SWAP(SWAP_RGB);
> +		dsi_write(msm_host, REG_DSI_VID_CFG1, 0);
> +	} else {
> +		/* Do not swap RGB colors */
> +		data = DSI_CMD_CFG0_RGB_SWAP(SWAP_RGB);
> +		data |= DSI_CMD_CFG0_DST_FORMAT(dsi_get_cmd_fmt(mipi_fmt));
> +		dsi_write(msm_host, REG_DSI_CMD_CFG0, data);
> +
> +		data = DSI_CMD_CFG1_WR_MEM_START(MIPI_DCS_WRITE_MEMORY_START) |
> +			DSI_CMD_CFG1_WR_MEM_CONTINUE(
> +					MIPI_DCS_WRITE_MEMORY_CONTINUE);
> +		/* Always insert DCS command */
> +		data |= DSI_CMD_CFG1_INSERT_DCS_COMMAND;
> +		dsi_write(msm_host, REG_DSI_CMD_CFG1, data);
> +	}
> +
> +	dsi_write(msm_host, REG_DSI_CMD_DMA_CTRL,
> +			DSI_CMD_DMA_CTRL_FROM_FRAME_BUFFER |
> +			DSI_CMD_DMA_CTRL_LOW_POWER);
> +
> +	data = 0;
> +	/* Always assume dedicated TE pin */
> +	data |= DSI_TRIG_CTRL_TE;
> +	data |= DSI_TRIG_CTRL_MDP_TRIGGER(TRIGGER_NONE);
> +	data |= DSI_TRIG_CTRL_DMA_TRIGGER(TRIGGER_SW);
> +	data |= DSI_TRIG_CTRL_STREAM(msm_host->channel);
> +	if ((msm_host->cfg->major == MSM_DSI_VER_MAJOR_6G) &&
> +		(msm_host->cfg->minor >= MSM_DSI_6G_VER_MINOR_V1_2))
> +		data |= DSI_TRIG_CTRL_BLOCK_DMA_WITHIN_FRAME;
> +	dsi_write(msm_host, REG_DSI_TRIG_CTRL, data);
> +
> +	data = DSI_CLKOUT_TIMING_CTRL_T_CLK_POST(clk_post) |
> +		DSI_CLKOUT_TIMING_CTRL_T_CLK_PRE(clk_pre);
> +	dsi_write(msm_host, REG_DSI_CLKOUT_TIMING_CTRL, data);
> +
> +	data = 0;
> +	if (!(flags & MIPI_DSI_MODE_EOT_PACKET))
> +		data |= DSI_EOT_PACKET_CTRL_TX_EOT_APPEND;
> +	dsi_write(msm_host, REG_DSI_EOT_PACKET_CTRL, data);
> +
> +	/* allow only ack-err-status to generate interrupt */
> +	dsi_write(msm_host, REG_DSI_ERR_INT_MASK0, 0x13ff3fe0);
> +
> +	dsi_intr_ctrl(msm_host, DSI_IRQ_MASK_ERROR, 1);
> +
> +	dsi_write(msm_host, REG_DSI_CLK_CTRL,
> +		DSI_CLK_CTRL_AHBS_HCLK_ON | DSI_CLK_CTRL_AHBM_SCLK_ON |
> +		DSI_CLK_CTRL_PCLK_ON | DSI_CLK_CTRL_DSICLK_ON |
> +		DSI_CLK_CTRL_BYTECLK_ON | DSI_CLK_CTRL_ESCCLK_ON |
> +		DSI_CLK_CTRL_FORCE_ON_DYN_AHBM_HCLK);
> +
> +	data = DSI_CTRL_CLK_EN;
> +
> +	DBG("lane number=%d", msm_host->lanes);
> +	if (msm_host->lanes == 2) {
> +		data |= DSI_CTRL_LANE1 | DSI_CTRL_LANE2;
> +		/* swap lanes for 2-lane panel for better performance */
> +		dsi_write(msm_host, REG_DSI_LANE_SWAP_CTRL,
> +			DSI_LANE_SWAP_CTRL_DLN_SWAP_SEL(LANE_SWAP_1230));
> +	} else {
> +		/* Take 4 lanes as default */
> +		data |= DSI_CTRL_LANE0 | DSI_CTRL_LANE1 | DSI_CTRL_LANE2 |
> +			DSI_CTRL_LANE3;
> +		/* Do not swap lanes for 4-lane panel */
> +		dsi_write(msm_host, REG_DSI_LANE_SWAP_CTRL,
> +			DSI_LANE_SWAP_CTRL_DLN_SWAP_SEL(LANE_SWAP_0123));
> +	}
> +	data |= DSI_CTRL_ENABLE;
> +
> +	dsi_write(msm_host, REG_DSI_CTRL, data);
> +}
> +
> +static void dsi_timing_setup(struct msm_dsi_host *msm_host)
> +{
> +	struct drm_display_mode *mode = msm_host->mode;
> +	u32 hs_start = 0, vs_start = 0; /* take sync start as 0 */
> +	u32 h_total = mode->htotal;
> +	u32 v_total = mode->vtotal;
> +	u32 hs_end = mode->hsync_end - mode->hsync_start;
> +	u32 vs_end = mode->vsync_end - mode->vsync_start;
> +	u32 ha_start = h_total - mode->hsync_start;
> +	u32 ha_end = ha_start + mode->hdisplay;
> +	u32 va_start = v_total - mode->vsync_start;
> +	u32 va_end = va_start + mode->vdisplay;
> +	u32 wc;
> +
> +	DBG("");
> +
> +	if (msm_host->mode_flags & MIPI_DSI_MODE_VIDEO) {
> +		dsi_write(msm_host, REG_DSI_ACTIVE_H,
> +			DSI_ACTIVE_H_START(ha_start) |
> +			DSI_ACTIVE_H_END(ha_end));
> +		dsi_write(msm_host, REG_DSI_ACTIVE_V,
> +			DSI_ACTIVE_V_START(va_start) |
> +			DSI_ACTIVE_V_END(va_end));
> +		dsi_write(msm_host, REG_DSI_TOTAL,
> +			DSI_TOTAL_H_TOTAL(h_total - 1) |
> +			DSI_TOTAL_V_TOTAL(v_total - 1));
> +
> +		dsi_write(msm_host, REG_DSI_ACTIVE_HSYNC,
> +			DSI_ACTIVE_HSYNC_START(hs_start) |
> +			DSI_ACTIVE_HSYNC_END(hs_end));
> +		dsi_write(msm_host, REG_DSI_ACTIVE_VSYNC_HPOS, 0);
> +		dsi_write(msm_host, REG_DSI_ACTIVE_VSYNC_VPOS,
> +			DSI_ACTIVE_VSYNC_VPOS_START(vs_start) |
> +			DSI_ACTIVE_VSYNC_VPOS_END(vs_end));
> +	} else {		/* command mode */
> +		/* image data and 1 byte write_memory_start cmd */
> +		wc = mode->hdisplay * dsi_get_bpp(msm_host->format) / 8 + 1;
> +
> +		dsi_write(msm_host, REG_DSI_CMD_MDP_STREAM_CTRL,
> +			DSI_CMD_MDP_STREAM_CTRL_WORD_COUNT(wc) |
> +			DSI_CMD_MDP_STREAM_CTRL_VIRTUAL_CHANNEL(
> +					msm_host->channel) |
> +			DSI_CMD_MDP_STREAM_CTRL_DATA_TYPE(
> +					MIPI_DSI_DCS_LONG_WRITE));
> +
> +		dsi_write(msm_host, REG_DSI_CMD_MDP_STREAM_TOTAL,
> +			DSI_CMD_MDP_STREAM_TOTAL_H_TOTAL(mode->hdisplay) |
> +			DSI_CMD_MDP_STREAM_TOTAL_V_TOTAL(mode->vdisplay));
> +	}
> +}
> +
> +static void dsi_sw_reset(struct msm_dsi_host *msm_host)
> +{
> +	dsi_write(msm_host, REG_DSI_CLK_CTRL,
> +		DSI_CLK_CTRL_AHBS_HCLK_ON | DSI_CLK_CTRL_AHBM_SCLK_ON |
> +		DSI_CLK_CTRL_PCLK_ON | DSI_CLK_CTRL_DSICLK_ON |
> +		DSI_CLK_CTRL_BYTECLK_ON | DSI_CLK_CTRL_ESCCLK_ON |
> +		DSI_CLK_CTRL_FORCE_ON_DYN_AHBM_HCLK);

The same 7 bits seem to be set elsewhere, maybe make this a macro 
DSI_ENABLE_CLKS or something similar?

> +	wmb(); /* clocks need to be enabled before reset */
> +
> +	dsi_write(msm_host, REG_DSI_RESET, 1);
> +	wmb(); /* make sure reset happen */
> +	dsi_write(msm_host, REG_DSI_RESET, 0);
> +}
> +
> +static void dsi_op_mode_config(struct msm_dsi_host *msm_host,
> +					bool video_mode, bool enable)
> +{
> +	u32 dsi_ctrl;
> +
> +	dsi_ctrl = dsi_read(msm_host, REG_DSI_CTRL);
> +
> +	if (!enable) {
> +		dsi_ctrl &= ~(DSI_CTRL_ENABLE | DSI_CTRL_VID_MODE_EN |
> +				DSI_CTRL_CMD_MODE_EN);
> +		dsi_intr_ctrl(msm_host, DSI_IRQ_MASK_CMD_MDP_DONE |
> +					DSI_IRQ_MASK_VIDEO_DONE, 0);
> +	} else {
> +		if (video_mode) {
> +			dsi_ctrl |= DSI_CTRL_VID_MODE_EN;
> +		} else {		/* command mode */
> +			dsi_ctrl |= DSI_CTRL_CMD_MODE_EN;
> +			dsi_intr_ctrl(msm_host, DSI_IRQ_MASK_CMD_MDP_DONE, 1);
> +		}
> +		dsi_ctrl |= DSI_CTRL_ENABLE;
> +	}
> +
> +	dsi_write(msm_host, REG_DSI_CTRL, dsi_ctrl);
> +}
> +
> +static void dsi_set_tx_power_mode(int mode, struct msm_dsi_host *msm_host)
> +{
> +	u32 data;
> +
> +	data = dsi_read(msm_host, REG_DSI_CMD_DMA_CTRL);
> +
> +	if (mode == 0)
> +		data &= ~DSI_CMD_DMA_CTRL_LOW_POWER;
> +	else
> +		data |= DSI_CMD_DMA_CTRL_LOW_POWER;
> +
> +	dsi_write(msm_host, REG_DSI_CMD_DMA_CTRL, data);
> +}
> +
> +static void dsi_wait4video_done(struct msm_dsi_host *msm_host)
> +{
> +	dsi_intr_ctrl(msm_host, DSI_IRQ_MASK_VIDEO_DONE, 1);
> +
> +	reinit_completion(&msm_host->video_comp);
> +
> +	wait_for_completion_timeout(&msm_host->video_comp,
> +			msecs_to_jiffies(70));
> +
> +	dsi_intr_ctrl(msm_host, DSI_IRQ_MASK_VIDEO_DONE, 0);
> +}
> +
> +static void dsi_wait4video_eng_busy(struct msm_dsi_host *msm_host)
> +{
> +	if (!(msm_host->mode_flags & MIPI_DSI_MODE_VIDEO))
> +		return;
> +
> +	if (msm_host->power_on) {
> +		dsi_wait4video_done(msm_host);
> +		/* delay 4 ms to skip BLLP */
> +		usleep_range(2000, 4000);
> +	}
> +}
> +
> +/* dsi_cmd */
> +static int dsi_tx_buf_alloc(struct msm_dsi_host *msm_host, int size)
> +{
> +	struct drm_device *dev = msm_host->dev;
> +	int ret;
> +	u32 iova;
> +
> +	mutex_lock(&dev->struct_mutex);
> +	msm_host->tx_gem_obj = msm_gem_new(dev, size, MSM_BO_UNCACHED);
> +	if (IS_ERR(msm_host->tx_gem_obj)) {
> +		ret = PTR_ERR(msm_host->tx_gem_obj);
> +		pr_err("%s: failed to allocate gem, %d\n", __func__, ret);
> +		msm_host->tx_gem_obj = NULL;
> +		mutex_unlock(&dev->struct_mutex);
> +		return ret;
> +	}
> +
> +	ret = msm_gem_get_iova_locked(msm_host->tx_gem_obj, 0, &iova);
> +	if (ret) {
> +		pr_err("%s: failed to get iova, %d\n", __func__, ret);
> +		return ret;
> +	}
> +	mutex_unlock(&dev->struct_mutex);
> +
> +	if (iova & 0x07) {
> +		pr_err("%s: buf NOT 8 bytes aligned\n", __func__);
> +		return -EINVAL;
> +	}
> +
> +	return 0;
> +}
> +
> +static void dsi_tx_buf_free(struct msm_dsi_host *msm_host)
> +{
> +	struct drm_device *dev = msm_host->dev;
> +
> +	if (msm_host->tx_gem_obj) {
> +		msm_gem_put_iova(msm_host->tx_gem_obj, 0);
> +		mutex_lock(&dev->struct_mutex);
> +		msm_gem_free_object(msm_host->tx_gem_obj);
> +		msm_host->tx_gem_obj = NULL;
> +		mutex_unlock(&dev->struct_mutex);
> +	}
> +}
> +
> +/*
> + * prepare cmd buffer to be txed
> + */
> +static int dsi_cmd_dma_add(struct drm_gem_object *tx_gem,
> +			const struct mipi_dsi_msg *msg)
> +{
> +	struct mipi_dsi_packet packet;
> +	int len;
> +	int ret = 0;
> +	u8 *data;
> +
> +	ret = mipi_dsi_create_packet(&packet, msg);
> +	if (ret) {
> +		pr_err("%s: create packet failed, %d\n", __func__, ret);
> +		return ret;
> +	}
> +	len = (packet.size + 3) & (~0x3);
> +
> +	if (len > tx_gem->size) {
> +		pr_err("%s: packet size is too big\n", __func__);
> +		return -EINVAL;
> +	}
> +
> +	data = msm_gem_vaddr(tx_gem);
> +
> +	if (IS_ERR(data)) {
> +		ret = PTR_ERR(data);
> +		pr_err("%s: get vaddr failed, %d\n", __func__, ret);
> +		return ret;
> +	}
> +
> +	/* MSM specific command format in memory */
> +	data[0] = packet.header[1];
> +	data[1] = packet.header[2];
> +	data[2] = packet.header[0];
> +	data[3] = BIT(7); /* Last packet */
> +	if (mipi_dsi_packet_format_is_long(msg->type))
> +		data[3] |= BIT(6);
> +	if (msg->rx_buf && msg->rx_len)
> +		data[3] |= BIT(5);
> +
> +	/* Long packet */
> +	if (packet.payload && packet.payload_length)
> +		memcpy(data + 4, packet.payload, packet.payload_length);
> +
> +	/* Append 0xff to the end */
> +	if (packet.size < len)
> +		memset(data + packet.size, 0xff, len - packet.size);
> +
> +	return len;
> +}
> +
> +/*
> + * dsi_short_read1_resp: 1 parameter
> + */
> +static int dsi_short_read1_resp(u8 *buf, const struct mipi_dsi_msg *msg)
> +{
> +	u8 *data = msg->rx_buf;
> +	if (data && (msg->rx_len >= 1)) {
> +		*data = buf[1]; /* strip out dcs type */
> +		return 1;
> +	} else {
> +		pr_err("%s: read data does not match with rx_buf len %d\n",
> +			__func__, msg->rx_len);
> +		return -EINVAL;
> +	}
> +}
> +
> +/*
> + * dsi_short_read2_resp: 2 parameter
> + */
> +static int dsi_short_read2_resp(u8 *buf, const struct mipi_dsi_msg *msg)
> +{
> +	u8 *data = msg->rx_buf;
> +	if (data && (msg->rx_len >= 2)) {
> +		data[0] = buf[1]; /* strip out dcs type */
> +		data[1] = buf[2];
> +		return 2;
> +	} else {
> +		pr_err("%s: read data does not match with rx_buf len %d\n",
> +			__func__, msg->rx_len);
> +		return -EINVAL;
> +	}
> +}
> +
> +static int dsi_long_read_resp(u8 *buf, const struct mipi_dsi_msg *msg)
> +{
> +	/* strip out 4 byte dcs header */
> +	if (msg->rx_buf && msg->rx_len)
> +		memcpy(msg->rx_buf, buf + 4, msg->rx_len);
> +
> +	return msg->rx_len;
> +}
> +
> +
> +static int dsi_cmd_dma_tx(struct msm_dsi_host *msm_host, int len)
> +{
> +	int ret = 0;
> +	u32 iova;
> +	bool triggered;
> +
> +	ret = msm_gem_get_iova(msm_host->tx_gem_obj, 0, &iova);
> +	if (ret) {
> +		pr_err("%s: failed to get iova: %d\n", __func__, ret);
> +		return ret;
> +	}
> +
> +	reinit_completion(&msm_host->dma_comp);
> +
> +	dsi_wait4video_eng_busy(msm_host);
> +
> +	triggered = msm_dsi_manager_cmd_xfer_trigger(
> +						msm_host->id, iova, len);
> +	if (triggered) {
> +		ret = wait_for_completion_timeout(&msm_host->dma_comp,
> +					msecs_to_jiffies(200));
> +		DBG("ret=%d", ret);
> +		if (ret == 0)
> +			ret = -ETIMEDOUT;
> +		else
> +			ret = len;
> +	} else
> +		ret = len;
> +
> +	return ret;
> +}
> +
> +static int dsi_cmd_dma_rx(struct msm_dsi_host *msm_host,
> +			u8 *buf, int rx_byte, int pkt_size)
> +{
> +	u32 *lp, *temp, data;
> +	int i, j = 0, cnt;
> +	bool ack_error = false;
> +	u32 read_cnt;
> +	u8 reg[16];
> +	int repeated_bytes = 0;
> +	int buf_offset = buf - msm_host->rx_buf;
> +
> +	lp = (u32 *)buf;
> +	temp = (u32 *)reg;
> +	cnt = (rx_byte + 3) >> 2;
> +	if (cnt > 4)
> +		cnt = 4; /* 4 x 32 bits registers only */
> +
> +	/* Calculate real read data count */
> +	read_cnt = dsi_read(msm_host, 0x1d4) >> 16;
> +
> +	ack_error = (rx_byte == 4) ?
> +		(read_cnt == 8) : /* short pkt + 4-byte error pkt */
> +		(read_cnt == (pkt_size + 6 + 4)); /* long pkt+4-byte error pkt*/
> +
> +	if (ack_error)
> +		read_cnt -= 4; /* Remove 4 byte error pkt */
> +
> +	/*
> +	 * In case of multiple reads from the panel, after the first read, there
> +	 * is possibility that there are some bytes in the payload repeating in
> +	 * the RDBK_DATA registers. Since we read all the parameters from the
> +	 * panel right from the first byte for every pass. We need to skip the
> +	 * repeating bytes and then append the new parameters to the rx buffer.
> +	 */
> +	if (read_cnt > 16) {
> +		int bytes_shifted;
> +		/* Any data more than 16 bytes will be shifted out.
> +		 * The temp read buffer should already contain these bytes.
> +		 * The remaining bytes in read buffer are the repeated bytes.
> +		 */
> +		bytes_shifted = read_cnt - 16;
> +		repeated_bytes = buf_offset - bytes_shifted;
> +	}
> +
> +	for (i = cnt - 1; i >= 0; i--) {
> +		data = dsi_read(msm_host, REG_DSI_RDBK_DATA(i));
> +		*temp++ = ntohl(data); /* to host byte order */
> +		DBG("data = 0x%x and ntohl(data) = 0x%x\n", data, ntohl(data));
> +	}
> +
> +	for (i = repeated_bytes; i < 16; i++)
> +		buf[j++] = reg[i];
> +
> +	return j;
> +}
> +
> +static int dsi_cmds2buf_tx(struct msm_dsi_host *msm_host,
> +				const struct mipi_dsi_msg *msg)
> +{
> +	int len, ret;
> +	int bllp_len = msm_host->mode->hdisplay *
> +			dsi_get_bpp(msm_host->format) / 8;
> +
> +	len = dsi_cmd_dma_add(msm_host->tx_gem_obj, msg);
> +	if (!len) {
> +		pr_err("%s: failed to add cmd type = 0x%x\n",
> +			__func__,  msg->type);
> +		return -EINVAL;
> +	}
> +
> +	/* for video mode, do not send cmds more than
> +	* one pixel line, since it only transmit it
> +	* during BLLP.
> +	*/
> +	/* TODO: if the command is sent in LP mode, the bit rate is only
> +	 * half of esc clk rate. In this case, if the video is already
> +	 * actively streaming, we need to check more carefully if the
> +	 * command can be fit into one BLLP.
> +	 */
> +	if ((msm_host->mode_flags & MIPI_DSI_MODE_VIDEO) && (len > bllp_len)) {
> +		pr_err("%s: cmd cannot fit into BLLP period, len=%d\n",
> +			__func__, len);
> +		return -EINVAL;
> +	}
> +
> +	ret = dsi_cmd_dma_tx(msm_host, len);
> +	if (ret < len) {
> +		pr_err("%s: cmd dma tx failed, type=0x%x, data0=0x%x, len=%d\n",
> +			__func__, msg->type, (*(u8 *)(msg->tx_buf)), len);
> +		return -ECOMM;
> +	}
> +
> +	return len;
> +}
> +
> +static void dsi_sw_reset_restore(struct msm_dsi_host *msm_host)
> +{
> +	u32 data0, data1;
> +
> +	data0 = dsi_read(msm_host, REG_DSI_CTRL);
> +	data1 = data0;
> +	data1 &= ~DSI_CTRL_ENABLE;
> +	dsi_write(msm_host, REG_DSI_CTRL, data1);
> +	/*
> +	 * dsi controller need to be disabled before
> +	 * clocks turned on
> +	 */
> +	wmb();
> +
> +	dsi_write(msm_host, REG_DSI_CLK_CTRL,
> +		DSI_CLK_CTRL_AHBS_HCLK_ON | DSI_CLK_CTRL_AHBM_SCLK_ON |
> +		DSI_CLK_CTRL_PCLK_ON | DSI_CLK_CTRL_DSICLK_ON |
> +		DSI_CLK_CTRL_BYTECLK_ON | DSI_CLK_CTRL_ESCCLK_ON |
> +		DSI_CLK_CTRL_FORCE_ON_DYN_AHBM_HCLK);
> +	wmb();	/* make sure clocks enabled */
> +
> +	/* dsi controller can only be reset while clocks are running */
> +	dsi_write(msm_host, REG_DSI_RESET, 1);
> +	wmb();	/* make sure reset happen */
> +	dsi_write(msm_host, REG_DSI_RESET, 0);
> +	wmb();	/* controller out of reset */
> +	dsi_write(msm_host, REG_DSI_CTRL, data0);
> +	wmb();	/* make sure dsi controller enabled again */
> +}
> +
> +static void dsi_err_worker(struct work_struct *work)
> +{
> +	struct msm_dsi_host *msm_host =
> +		container_of(work, struct msm_dsi_host, err_work);
> +	u32 status = msm_host->err_work_state;
> +
> +	pr_err("%s: status=%x\n", __func__, status);
> +	if (status & DSI_ERR_STATE_MDP_FIFO_UNDERFLOW)
> +		dsi_sw_reset_restore(msm_host);
> +
> +	/* It is safe to clear here because error irq is disabled. */
> +	msm_host->err_work_state = 0;
> +
> +	/* enable dsi error interrupt */
> +	dsi_intr_ctrl(msm_host, DSI_IRQ_MASK_ERROR, 1);
> +}
> +
> +static void dsi_ack_err_status(struct msm_dsi_host *msm_host)
> +{
> +	u32 status;
> +
> +	status = dsi_read(msm_host, REG_DSI_ACK_ERR_STATUS);
> +
> +	if (status) {
> +		dsi_write(msm_host, REG_DSI_ACK_ERR_STATUS, status);
> +		/* Writing of an extra 0 needed to clear error bits */
> +		dsi_write(msm_host, REG_DSI_ACK_ERR_STATUS, 0);
> +		msm_host->err_work_state |= DSI_ERR_STATE_ACK;
> +	}
> +}
> +
> +static void dsi_timeout_status(struct msm_dsi_host *msm_host)
> +{
> +	u32 status;
> +
> +	status = dsi_read(msm_host, REG_DSI_TIMEOUT_STATUS);
> +
> +	if (status) {
> +		dsi_write(msm_host, REG_DSI_TIMEOUT_STATUS, status);
> +		msm_host->err_work_state |= DSI_ERR_STATE_TIMEOUT;
> +	}
> +}
> +
> +static void dsi_dln0_phy_err(struct msm_dsi_host *msm_host)
> +{
> +	u32 status;
> +
> +	status = dsi_read(msm_host, REG_DSI_DLN0_PHY_ERR);
> +
> +	if (status) {
> +		dsi_write(msm_host, REG_DSI_DLN0_PHY_ERR, status);
> +		msm_host->err_work_state |= DSI_ERR_STATE_DLN0_PHY;
> +	}
> +}
> +
> +static void dsi_fifo_status(struct msm_dsi_host *msm_host)
> +{
> +	u32 status;
> +
> +	status = dsi_read(msm_host, REG_DSI_FIFO_STATUS);
> +
> +	/* fifo underflow, overflow */
> +	if (status) {
> +		dsi_write(msm_host, REG_DSI_FIFO_STATUS, status);
> +		msm_host->err_work_state |= DSI_ERR_STATE_FIFO;
> +		if (status & DSI_FIFO_STATUS_CMD_MDP_FIFO_UNDERFLOW)
> +			msm_host->err_work_state |=
> +					DSI_ERR_STATE_MDP_FIFO_UNDERFLOW;
> +	}
> +}
> +
> +static void dsi_status(struct msm_dsi_host *msm_host)
> +{
> +	u32 status;
> +
> +	status = dsi_read(msm_host, REG_DSI_STATUS0);
> +
> +	if (status & DSI_STATUS0_INTERLEAVE_OP_CONTENTION) {
> +		dsi_write(msm_host, REG_DSI_STATUS0, status);
> +		msm_host->err_work_state |=
> +			DSI_ERR_STATE_INTERLEAVE_OP_CONTENTION;
> +	}
> +}
> +
> +static void dsi_clk_status(struct msm_dsi_host *msm_host)
> +{
> +	u32 status;
> +
> +	status = dsi_read(msm_host, REG_DSI_CLK_STATUS);
> +
> +	if (status & DSI_CLK_STATUS_PLL_UNLOCKED) {
> +		dsi_write(msm_host, REG_DSI_CLK_STATUS, status);
> +		msm_host->err_work_state |= DSI_ERR_STATE_PLL_UNLOCKED;
> +	}
> +}
> +
> +static void dsi_error(struct msm_dsi_host *msm_host)
> +{
> +	/* disable dsi error interrupt */
> +	dsi_intr_ctrl(msm_host, DSI_IRQ_MASK_ERROR, 0);
> +
> +	dsi_clk_status(msm_host);
> +	dsi_fifo_status(msm_host);
> +	dsi_ack_err_status(msm_host);
> +	dsi_timeout_status(msm_host);
> +	dsi_status(msm_host);
> +	dsi_dln0_phy_err(msm_host);
> +
> +	queue_work(msm_host->workqueue, &msm_host->err_work);
> +}
> +
> +static irqreturn_t dsi_host_irq(int irq, void *ptr)
> +{
> +	struct msm_dsi_host *msm_host = ptr;
> +	u32 isr;
> +	unsigned long flags;
> +
> +	if (!msm_host->ctrl_base)
> +		return IRQ_HANDLED;
> +
> +	spin_lock_irqsave(&msm_host->intr_lock, flags);
> +	isr = dsi_read(msm_host, REG_DSI_INTR_CTRL);
> +	dsi_write(msm_host, REG_DSI_INTR_CTRL, isr);
> +	spin_unlock_irqrestore(&msm_host->intr_lock, flags);
> +
> +	DBG("isr=0x%x, id=%d\n", isr, msm_host->id);
> +
> +	if (isr & DSI_IRQ_ERROR)
> +		dsi_error(msm_host);
> +
> +	if (isr & DSI_IRQ_VIDEO_DONE)
> +		complete(&msm_host->video_comp);
> +
> +	if (isr & DSI_IRQ_CMD_DMA_DONE)
> +		complete(&msm_host->dma_comp);
> +
> +	return IRQ_HANDLED;
> +}
> +
> +int dsi_host_attach(struct mipi_dsi_host *host,
> +					struct mipi_dsi_device *dsi)
> +{
> +	struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
> +
> +	msm_host->channel = dsi->channel;
> +	msm_host->lanes = dsi->lanes;
> +	msm_host->format = dsi->format;
> +	msm_host->mode_flags = dsi->mode_flags;
> +
> +	msm_host->panel_node = dsi->dev.of_node;
> +
> +	DBG("id=%d", msm_host->id);
> +	if (msm_host->dev)
> +		drm_helper_hpd_irq_event(msm_host->dev);
> +
> +	return 0;
> +}
> +
> +int dsi_host_detach(struct mipi_dsi_host *host,
> +					struct mipi_dsi_device *dsi)
> +{
> +	struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
> +
> +	msm_host->panel_node = NULL;
> +
> +	DBG("id=%d", msm_host->id);
> +	if (msm_host->dev)
> +		drm_helper_hpd_irq_event(msm_host->dev);
> +
> +	return 0;
> +}
> +
> +ssize_t dsi_host_transfer(struct mipi_dsi_host *host,
> +					const struct mipi_dsi_msg *msg)
> +{
> +	struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
> +	int ret = -EINVAL;
> +
> +	if (!msg || !msm_host->power_on)
> +		return -EINVAL;
> +
> +	mutex_lock(&msm_host->cmd_mutex);
> +	ret = msm_dsi_manager_cmd_xfer(msm_host->id, msg);
> +	mutex_unlock(&msm_host->cmd_mutex);
> +
> +	return ret;
> +}
> +
> +static struct mipi_dsi_host_ops dsi_host_ops = {
> +	.attach = dsi_host_attach,
> +	.detach = dsi_host_detach,
> +	.transfer = dsi_host_transfer,
> +};
> +
> +int msm_dsi_host_init(struct msm_dsi *msm_dsi)
> +{
> +	struct msm_dsi_host *msm_host = NULL;
> +	struct platform_device *pdev = msm_dsi->pdev;
> +	int ret = 0;
> +
> +	msm_host = devm_kzalloc(&pdev->dev, sizeof(*msm_host), GFP_KERNEL);
> +	if (!msm_host) {
> +		pr_err("%s: FAILED: cannot alloc dsi host\n",
> +		       __func__);
> +		ret = -ENOMEM;
> +		goto fail;
> +	}
> +
> +	ret = of_property_read_u32(pdev->dev.of_node,
> +				"cell-index", &msm_host->id);

retrieving the instance number of a peripheral via a DT property like 
'cell-index' has been debated quite a bit in the past. I suppose it's 
not the best thing to do.

However, since the DSI instances in MDSS aren't completely identical(one 
acts a master and other slave in dual dsi mode), maybe we can get away 
with having a property like "qcom,dsi-master;", and that can be further 
used to identify whether this node is DSI_0 or DSI_1

> +	if (ret) {
> +		dev_err(&pdev->dev,
> +			"%s: Cell-index not specified, ret=%d\n",
> +			__func__, ret);
> +		return -EINVAL;
> +	}
> +	msm_host->pdev = pdev;
> +
> +	ret = dsi_clk_init(msm_host);
> +	if (ret) {
> +		pr_err("%s: unable to initialize dsi clks\n", __func__);
> +		goto fail;
> +	}
> +
> +	ret = dsi_gpio_init(msm_host);
> +	if (ret) {
> +		pr_err("%s: unable to initialize dsi gpios\n", __func__);
> +		goto fail;
> +	}
> +
> +	msm_host->ctrl_base = msm_ioremap(pdev, "dsi_ctrl", "DSI CTRL");
> +	if (IS_ERR(msm_host->ctrl_base)) {
> +		pr_err("%s: unable to map Dsi ctrl base\n", __func__);
> +		ret = PTR_ERR(msm_host->ctrl_base);
> +		goto fail;
> +	}
> +
> +	msm_host->cfg = dsi_get_config(msm_host);
> +	if (!msm_host->cfg) {
> +		ret = -EINVAL;
> +		pr_err("%s: get config failed\n", __func__);
> +		goto fail;
> +	}
> +
> +	ret = dsi_regulator_init(msm_host);
> +	if (ret)
> +		goto fail;
> +
> +	msm_host->rx_buf = devm_kzalloc(&pdev->dev, SZ_4K, GFP_KERNEL);
> +	if (!msm_host->rx_buf) {
> +		pr_err("%s: alloc rx temp buf failed\n", __func__);
> +		goto fail;
> +	}
> +
> +	init_completion(&msm_host->dma_comp);
> +	init_completion(&msm_host->video_comp);
> +	mutex_init(&msm_host->dev_mutex);
> +	mutex_init(&msm_host->cmd_mutex);
> +	mutex_init(&msm_host->clk_mutex);
> +	spin_lock_init(&msm_host->intr_lock);
> +
> +	/* setup workqueue */
> +	msm_host->workqueue = alloc_ordered_workqueue("dsi_drm_work", 0);
> +	INIT_WORK(&msm_host->err_work, dsi_err_worker);
> +
> +	msm_dsi->phy = msm_dsi_phy_init(pdev, msm_host->cfg->phy_type,
> +					msm_host->id);
> +	if (!msm_dsi->phy) {
> +		pr_err("%s: phy init failed\n", __func__);
> +		goto fail;
> +	}
> +	msm_dsi->host = &msm_host->base;
> +	msm_dsi->id = msm_host->id;
> +
> +	DBG("Dsi Host %d initialized\n", msm_host->id);
> +	return 0;
> +
> +fail:
> +	return ret;
> +}
> +
> +void msm_dsi_host_destroy(struct mipi_dsi_host *host)
> +{
> +	struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
> +
> +	DBG("");
> +	dsi_tx_buf_free(msm_host);
> +	if (msm_host->workqueue) {
> +		flush_workqueue(msm_host->workqueue);
> +		destroy_workqueue(msm_host->workqueue);
> +		msm_host->workqueue = NULL;
> +	}
> +
> +	mutex_destroy(&msm_host->clk_mutex);
> +	mutex_destroy(&msm_host->cmd_mutex);
> +	mutex_destroy(&msm_host->dev_mutex);
> +}
> +
> +int msm_dsi_host_modeset_init(struct mipi_dsi_host *host,
> +					struct drm_device *dev)
> +{
> +	struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
> +	struct platform_device *pdev = msm_host->pdev;
> +	int ret;
> +
> +	msm_host->irq = irq_of_parse_and_map(pdev->dev.of_node, 0);
> +	if (msm_host->irq < 0) {
> +		ret = msm_host->irq;
> +		dev_err(dev->dev, "failed to get irq: %d\n", ret);
> +		return -EINVAL;
> +	}
> +
> +	ret = devm_request_irq(&pdev->dev, msm_host->irq,
> +			dsi_host_irq, IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
> +			"dsi_isr", msm_host);
> +	if (ret < 0) {
> +		dev_err(&pdev->dev, "failed to request IRQ%u: %d\n",
> +				msm_host->irq, ret);
> +		return ret;
> +	}
> +
> +	msm_host->dev = dev;
> +	ret = dsi_tx_buf_alloc(msm_host, SZ_4K);
> +	if (ret) {
> +		pr_err("%s: alloc tx gem obj failed, %d\n", __func__, ret);
> +		return ret;
> +	}
> +
> +	return ret;
> +}
> +
> +int msm_dsi_host_register(struct mipi_dsi_host *host, bool check_defer)
> +{
> +	struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
> +	struct device_node *node;
> +	int ret;
> +
> +	/* Register mipi dsi host */
> +	if (!msm_host->registered) {
> +		host->dev = &msm_host->pdev->dev;
> +		host->ops = &dsi_host_ops;
> +		ret = mipi_dsi_host_register(host);
> +		if (ret)
> +			return ret;
> +
> +		msm_host->registered = true;
> +
> +		/* If the panel driver has not been probed after host register,
> +		 * we should defer the host's probe.
> +		 * It makes sure panel is connected when fbcon detects
> +		 * connector status and gets the proper display mode to
> +		 * create framebuffer.
> +		 */
> +		if (check_defer) {
> +			node = of_parse_phandle(msm_host->pdev->dev.of_node,
> +						"qcom,panel", 0);
> +			if (node) {
> +				if (!of_drm_find_panel(node))
> +					return -EPROBE_DEFER;
> +			}
> +		}
> +	}

We might have to defer probe multiple times before another dependency is 
met. The above approach will let the driver defer only once without the 
panel driver registered. During the second probe attempt, we'd just 
return since 'msm_host->registered' would be true.

I think we could move this check to end of dsi_init().

> +
> +	return 0;
> +}
> +
> +void msm_dsi_host_unregister(struct mipi_dsi_host *host)
> +{
> +	struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
> +
> +	if (msm_host->registered) {
> +		mipi_dsi_host_unregister(host);
> +		host->dev = NULL;
> +		host->ops = NULL;
> +		msm_host->registered = false;
> +	}
> +}
> +
> +int msm_dsi_host_xfer_prepare(struct mipi_dsi_host *host,
> +				const struct mipi_dsi_msg *msg)
> +{
> +	struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
> +
> +	/* TODO: make sure dsi_cmd_mdp is idle.
> +	 * Since DSI6G v1.2.0, we can set DSI_TRIG_CTRL.BLOCK_DMA_WITHIN_FRAME
> +	 * to ask H/W to wait until cmd mdp is idle. S/W wait is not needed.
> +	 * How to handle the old versions? Wait for mdp cmd done?
> +	 */
> +
> +	/*
> +	 * mdss interrupt is generated in mdp core clock domain
> +	 * mdp clock need to be enabled to receive dsi interrupt
> +	 */
> +	dsi_clk_ctrl(msm_host, 1);
> +
> +	/* TODO: vote for bus bandwidth */
> +
> +	if (!(msg->flags & MIPI_DSI_MSG_USE_LPM))
> +		dsi_set_tx_power_mode(0, msm_host);
> +
> +	msm_host->dma_cmd_ctrl_restore = dsi_read(msm_host, REG_DSI_CTRL);
> +	dsi_write(msm_host, REG_DSI_CTRL,
> +		msm_host->dma_cmd_ctrl_restore |
> +		DSI_CTRL_CMD_MODE_EN |
> +		DSI_CTRL_ENABLE);
> +	dsi_intr_ctrl(msm_host, DSI_IRQ_MASK_CMD_DMA_DONE, 1);
> +
> +	return 0;
> +}
> +
> +void msm_dsi_host_xfer_restore(struct mipi_dsi_host *host,
> +				const struct mipi_dsi_msg *msg)
> +{
> +	struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
> +
> +	dsi_intr_ctrl(msm_host, DSI_IRQ_MASK_CMD_DMA_DONE, 0);
> +	dsi_write(msm_host, REG_DSI_CTRL, msm_host->dma_cmd_ctrl_restore);
> +
> +	if (!(msg->flags & MIPI_DSI_MSG_USE_LPM))
> +		dsi_set_tx_power_mode(1, msm_host);
> +
> +	/* TODO: unvote for bus bandwidth */
> +
> +	dsi_clk_ctrl(msm_host, 0);
> +}
> +
> +int msm_dsi_host_cmd_tx(struct mipi_dsi_host *host,
> +				const struct mipi_dsi_msg *msg)
> +{
> +	struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
> +
> +	return dsi_cmds2buf_tx(msm_host, msg);
> +}
> +
> +int msm_dsi_host_cmd_rx(struct mipi_dsi_host *host,
> +				const struct mipi_dsi_msg *msg)
> +{
> +	struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
> +	int data_byte, rx_byte, dlen, end;
> +	int short_response, diff, pkt_size, ret = 0;
> +	char cmd;
> +	int rlen = msg->rx_len;
> +	u8 *buf;
> +
> +	if (rlen <= 2) {
> +		short_response = 1;
> +		pkt_size = rlen;
> +		rx_byte = 4;
> +	} else {
> +		short_response = 0;
> +		data_byte = 10;	/* first read */
> +		if (rlen < data_byte)
> +			pkt_size = rlen;
> +		else
> +			pkt_size = data_byte;
> +		rx_byte = data_byte + 6; /* 4 header + 2 crc */
> +	}
> +
> +	buf = msm_host->rx_buf;
> +	end = 0;
> +	while (!end) {
> +		u8 tx[2] = {pkt_size & 0xff, pkt_size >> 8};
> +		struct mipi_dsi_msg max_pkt_size_msg = {
> +			.channel = msg->channel,
> +			.type = MIPI_DSI_SET_MAXIMUM_RETURN_PACKET_SIZE,
> +			.tx_len = 2,
> +			.tx_buf = tx,
> +		};
> +
> +		DBG("rlen=%d pkt_size=%d rx_byte=%d",
> +			rlen, pkt_size, rx_byte);
> +
> +		ret = dsi_cmds2buf_tx(msm_host, &max_pkt_size_msg);
> +		if (ret < 2) {
> +			pr_err("%s: Set max pkt size failed, %d\n",
> +				__func__, ret);
> +			return -EINVAL;
> +		}
> +
> +		if ((msm_host->cfg->major == MSM_DSI_VER_MAJOR_6G) &&
> +			(msm_host->cfg->minor >= MSM_DSI_6G_VER_MINOR_V1_1)) {
> +			/* Clear the RDBK_DATA registers */
> +			dsi_write(msm_host, REG_DSI_RDBK_DATA_CTRL,
> +					DSI_RDBK_DATA_CTRL_CLR);
> +			wmb(); /* make sure the RDBK registers are cleared */
> +			dsi_write(msm_host, REG_DSI_RDBK_DATA_CTRL, 0);
> +			wmb(); /* release cleared status before transfer */
> +		}
> +
> +		ret = dsi_cmds2buf_tx(msm_host, msg);
> +		if (ret < msg->tx_len) {
> +			pr_err("%s: Read cmd Tx failed, %d\n", __func__, ret);
> +			return ret;
> +		}
> +
> +		/*
> +		 * once cmd_dma_done interrupt received,
> +		 * return data from client is ready and stored
> +		 * at RDBK_DATA register already
> +		 * since rx fifo is 16 bytes, dcs header is kept at first loop,
> +		 * after that dcs header lost during shift into registers
> +		 */
> +		dlen = dsi_cmd_dma_rx(msm_host, buf, rx_byte, pkt_size);
> +
> +		if (dlen <= 0)
> +			return 0;
> +
> +		if (short_response)
> +			break;
> +
> +		if (rlen <= data_byte) {
> +			diff = data_byte - rlen;
> +			end = 1;
> +		} else {
> +			diff = 0;
> +			rlen -= data_byte;
> +		}
> +
> +		if (!end) {
> +			dlen -= 2; /* 2 crc */
> +			dlen -= diff;
> +			buf += dlen;	/* next start position */
> +			data_byte = 14;	/* NOT first read */
> +			if (rlen < data_byte)
> +				pkt_size += rlen;
> +			else
> +				pkt_size += data_byte;
> +			DBG("buf=%x dlen=%d diff=%d\n", (int)buf, dlen, diff);
> +		}
> +	}
> +
> +	/*
> +	 * For single Long read, if the requested rlen < 10,
> +	 * we need to shift the start position of rx
> +	 * data buffer to skip the bytes which are not
> +	 * updated.
> +	 */
> +	if (pkt_size < 10 && !short_response)
> +		buf = msm_host->rx_buf + (10 - rlen);
> +	else
> +		buf = msm_host->rx_buf;
> +
> +	cmd = buf[0];
> +	switch (cmd) {
> +	case MIPI_DSI_RX_ACKNOWLEDGE_AND_ERROR_REPORT:
> +		pr_err("%s: rx ACK_ERR_PACLAGE\n", __func__);
> +		ret = 0;
> +	case MIPI_DSI_RX_GENERIC_SHORT_READ_RESPONSE_1BYTE:
> +	case MIPI_DSI_RX_DCS_SHORT_READ_RESPONSE_1BYTE:
> +		ret = dsi_short_read1_resp(buf, msg);
> +		break;
> +	case MIPI_DSI_RX_GENERIC_SHORT_READ_RESPONSE_2BYTE:
> +	case MIPI_DSI_RX_DCS_SHORT_READ_RESPONSE_2BYTE:
> +		ret = dsi_short_read2_resp(buf, msg);
> +		break;
> +	case MIPI_DSI_RX_GENERIC_LONG_READ_RESPONSE:
> +	case MIPI_DSI_RX_DCS_LONG_READ_RESPONSE:
> +		ret = dsi_long_read_resp(buf, msg);
> +		break;
> +	default:
> +		pr_warn("%s:Invalid response cmd\n", __func__);
> +		ret = 0;
> +	}
> +
> +	return ret;
> +}
> +
> +void msm_dsi_host_cmd_xfer_commit(struct mipi_dsi_host *host, u32 iova, u32 len)
> +{
> +	struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
> +
> +	dsi_write(msm_host, REG_DSI_DMA_BASE, iova);
> +	dsi_write(msm_host, REG_DSI_DMA_LEN, len);
> +	dsi_write(msm_host, REG_DSI_TRIG_DMA, 1);
> +
> +	/* Make sure trigger happens */
> +	wmb();
> +}
> +
> +int msm_dsi_host_enable(struct mipi_dsi_host *host)
> +{
> +	struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
> +
> +	dsi_op_mode_config(msm_host,
> +		!!(msm_host->mode_flags & MIPI_DSI_MODE_VIDEO), true);
> +
> +	/* TODO: clock should be turned off for command mode,
> +	 * and only turned on before MDP START.
> +	 * This part of code should be enabled once mdp driver support it.
> +	 */
> +	/* if (msm_panel->mode == MSM_DSI_CMD_MODE)
> +		dsi_clk_ctrl(msm_host, 0); */
> +
> +	return 0;
> +}
> +
> +int msm_dsi_host_disable(struct mipi_dsi_host *host)
> +{
> +	struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
> +
> +	dsi_op_mode_config(msm_host,
> +		!!(msm_host->mode_flags & MIPI_DSI_MODE_VIDEO), false);
> +
> +	/* Since we have disabled INTF, the video engine won't stop so that
> +	 * the cmd engine will be blocked.
> +	 * Reset to disable video engine so that we can send off cmd.
> +	 */
> +	dsi_sw_reset(msm_host);
> +
> +	return 0;
> +}
> +
> +int msm_dsi_host_power_on(struct mipi_dsi_host *host)
> +{
> +	struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
> +	u32 clk_pre, clk_post;
> +	int ret = 0;
> +
> +	mutex_lock(&msm_host->dev_mutex);
> +	if (msm_host->power_on) {
> +		DBG("dsi host already on");
> +		goto unlock_ret;
> +	}
> +
> +	ret = dsi_calc_clk_rate(msm_host);
> +	if (ret) {
> +		pr_err("%s: unable to calc clk rate, %d\n", __func__, ret);
> +		goto unlock_ret;
> +	}
> +
> +	ret = dsi_host_regulator_enable(msm_host);
> +	if (ret) {
> +		pr_err("%s:Failed to enable vregs.ret=%d\n",
> +			__func__, ret);
> +		goto unlock_ret;
> +	}
> +
> +	ret = dsi_bus_clk_enable(msm_host);
> +	if (ret) {
> +		pr_err("%s: failed to enable bus clocks, %d\n", __func__, ret);
> +		goto fail_disable_reg;
> +	}
> +
> +	dsi_phy_sw_reset(msm_host);
> +	ret = msm_dsi_manager_phy_enable(msm_host->id,
> +					msm_host->byte_clk_rate * 8,
> +					clk_get_rate(msm_host->esc_clk),
> +					&clk_pre, &clk_post);
> +	dsi_bus_clk_disable(msm_host);
> +	if (ret) {
> +		pr_err("%s: failed to enable phy, %d\n", __func__, ret);
> +		goto fail_disable_reg;
> +	}
> +
> +	ret = dsi_clk_ctrl(msm_host, 1);
> +	if (ret) {
> +		pr_err("%s: failed to enable clocks. ret=%d\n", __func__, ret);
> +		goto fail_disable_reg;
> +	}
> +
> +	dsi_timing_setup(msm_host);
> +	dsi_sw_reset(msm_host);
> +	dsi_ctrl_config(msm_host, true, clk_pre, clk_post);
> +
> +	if (msm_host->disp_en_gpio)
> +		gpiod_set_value(msm_host->disp_en_gpio, 1);
> +
> +	msm_host->power_on = true;
> +	mutex_unlock(&msm_host->dev_mutex);
> +
> +	return ret;
> +
> +fail_disable_reg:
> +	dsi_host_regulator_disable(msm_host);
> +unlock_ret:
> +	mutex_unlock(&msm_host->dev_mutex);
> +	return ret;
> +}
> +
> +int msm_dsi_host_power_off(struct mipi_dsi_host *host)
> +{
> +	struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
> +	int ret = 0;
> +
> +	mutex_lock(&msm_host->dev_mutex);
> +	if (!msm_host->power_on) {
> +		DBG("dsi host already off");
> +		goto unlock_ret;
> +	}
> +
> +	dsi_ctrl_config(msm_host, false, 0, 0);
> +
> +	if (msm_host->disp_en_gpio)
> +		gpiod_set_value(msm_host->disp_en_gpio, 0);
> +
> +	msm_dsi_manager_phy_disable(msm_host->id);
> +
> +	dsi_clk_ctrl(msm_host, 0);
> +
> +	dsi_host_regulator_disable(msm_host);
> +
> +	DBG("-");
> +
> +	msm_host->power_on = false;
> +
> +unlock_ret:
> +	mutex_unlock(&msm_host->dev_mutex);
> +	return ret;
> +}
> +
> +int msm_dsi_host_set_display_mode(struct mipi_dsi_host *host,
> +					struct drm_display_mode *mode)
> +{
> +	struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
> +
> +	if (msm_host->mode) {
> +		drm_mode_destroy(msm_host->dev, msm_host->mode);
> +		msm_host->mode = NULL;
> +	}
> +
> +	msm_host->mode = drm_mode_duplicate(msm_host->dev, mode);
> +	if (IS_ERR(msm_host->mode)) {
> +		pr_err("%s: cannot duplicate mode", __func__);
> +		return PTR_ERR(msm_host->mode);
> +	}
> +
> +	return 0;
> +}
> +
> +struct drm_panel *msm_dsi_host_get_panel(struct mipi_dsi_host *host,
> +				unsigned long *panel_flags)
> +{
> +	struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
> +	struct drm_panel *panel;
> +
> +	panel = of_drm_find_panel(msm_host->panel_node);
> +	if (panel_flags)
> +			*panel_flags = msm_host->mode_flags;
> +
> +	return panel;
> +}
> +
> diff --git a/drivers/gpu/drm/msm/dsi/dsi_manager.c b/drivers/gpu/drm/msm/dsi/dsi_manager.c
> new file mode 100644
> index 0000000..8eaa885
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dsi/dsi_manager.c
> @@ -0,0 +1,706 @@
> +/*
> + * Copyright (c) 2015, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + */
> +
> +#include "msm_kms.h"
> +#include "dsi.h"
> +
> +struct msm_dsi_manager {
> +	struct msm_dsi *dsi[DSI_MAX];
> +
> +	bool is_dual_panel;
> +	bool is_sync_needed;
> +	int master_panel_id;
> +};
> +
> +static struct msm_dsi_manager msm_dsim_glb;
> +
> +#define IS_DUAL_PANEL()		(msm_dsim_glb.is_dual_panel)
> +#define IS_SYNC_NEEDED()	(msm_dsim_glb.is_sync_needed)
> +#define IS_MASTER_PANEL(id)	(msm_dsim_glb.master_panel_id == id)
> +
> +static inline struct msm_dsi *dsi_mgr_get_dsi(int id)
> +{
> +	return msm_dsim_glb.dsi[id];
> +}
> +
> +static inline struct msm_dsi *dsi_mgr_get_other_dsi(int id)
> +{
> +	return msm_dsim_glb.dsi[(id + 1) % DSI_MAX];
> +}
> +
> +static int dsi_mgr_parse_dual_panel(struct device_node *np, int id)
> +{
> +	struct msm_dsi_manager *msm_dsim = &msm_dsim_glb;
> +
> +	/* We assume 2 dsi nodes have the same information of dual-panel and
> +	 * sync-mode, and only one node specifies master in case of dual mode.
> +	 */
> +	if (!msm_dsim->is_dual_panel)
> +		msm_dsim->is_dual_panel = of_property_read_bool(
> +						np, "qcom,dual-panel-mode");
> +
> +	if (msm_dsim->is_dual_panel) {
> +		if (of_property_read_bool(np, "qcom,master-panel"))
> +			msm_dsim->master_panel_id = id;
> +		if (!msm_dsim->is_sync_needed)
> +			msm_dsim->is_sync_needed = of_property_read_bool(
> +					np, "qcom,sync-dual-panel");
> +	}
> +
> +	return 0;
> +}
> +
> +struct dsi_connector {
> +	struct drm_connector base;
> +	int id;
> +};
> +
> +struct dsi_bridge {
> +	struct drm_bridge base;
> +	int id;
> +};
> +
> +#define to_dsi_connector(x) container_of(x, struct dsi_connector, base)
> +#define to_dsi_bridge(x) container_of(x, struct dsi_bridge, base)
> +
> +static inline int dsi_mgr_connector_get_id(struct drm_connector *connector)
> +{
> +	struct dsi_connector *dsi_connector = to_dsi_connector(connector);
> +	return dsi_connector->id;
> +}
> +
> +static int dsi_mgr_bridge_get_id(struct drm_bridge *bridge)
> +{
> +	struct dsi_bridge *dsi_bridge = to_dsi_bridge(bridge);
> +	return dsi_bridge->id;
> +}
> +
> +static enum drm_connector_status dsi_mgr_connector_detect(
> +		struct drm_connector *connector, bool force)
> +{
> +	int id = dsi_mgr_connector_get_id(connector);
> +	struct msm_dsi *msm_dsi = dsi_mgr_get_dsi(id);
> +	struct msm_dsi *other_dsi = dsi_mgr_get_other_dsi(id);
> +	struct msm_drm_private *priv = connector->dev->dev_private;
> +	struct msm_kms *kms = priv->kms;
> +
> +	DBG("id=%d", id);
> +	if (!msm_dsi->panel) {
> +		msm_dsi->panel = msm_dsi_host_get_panel(msm_dsi->host,
> +						&msm_dsi->panel_flags);
> +
> +		/* There is only 1 panel in the global panel list
> +		 * for dual panel mode. Therefore slave dsi should get
> +		 * the drm_panel instance from master dsi, and
> +		 * keep using the panel flags got from the current DSI link.
> +		 */
> +		if (!msm_dsi->panel && IS_DUAL_PANEL() &&
> +			!IS_MASTER_PANEL(id) && other_dsi)
> +			msm_dsi->panel = msm_dsi_host_get_panel(
> +					other_dsi->host, NULL);
> +
> +		if (msm_dsi->panel && IS_DUAL_PANEL())
> +			drm_object_attach_property(&connector->base,
> +				connector->dev->mode_config.tile_property, 0);
> +
> +		/* Set split display info to kms only once */
> +		if (msm_dsi->panel && IS_DUAL_PANEL() &&
> +			(id == DSI_ENCODER_MASTER) && other_dsi) {
> +			int vid_enc_id = MSM_DSI_VIDEO_ENCODER_ID;
> +			int cmd_enc_id = MSM_DSI_CMD_ENCODER_ID;
> +			bool vid_panel =
> +				msm_dsi->panel_flags & MIPI_DSI_MODE_VIDEO;
> +			struct drm_encoder *encoder = vid_panel ?
> +				msm_dsi->base.encoders[vid_enc_id] :
> +				msm_dsi->base.encoders[cmd_enc_id];
> +			struct drm_encoder *slave_enc = vid_panel ?
> +				other_dsi->base.encoders[vid_enc_id] :
> +				other_dsi->base.encoders[cmd_enc_id];
> +
> +			if (kms->funcs->set_split_display)
> +				kms->funcs->set_split_display(kms, encoder,
> +						slave_enc, !vid_panel);
> +			else
> +				pr_err("mdp does not support dual panel\n");
> +		}
> +	}
> +
> +	return msm_dsi->panel ? connector_status_connected :
> +		connector_status_disconnected;
> +}
> +
> +static void dsi_mgr_connector_destroy(struct drm_connector *connector)
> +{
> +	DBG("");
> +	drm_connector_unregister(connector);
> +	drm_connector_cleanup(connector);
> +}
> +
> +static void dsi_dual_connector_fix_modes(struct drm_connector *connector)
> +{
> +	struct drm_display_mode *mode, *m;
> +
> +	/* Only support left-right mode */
> +	list_for_each_entry_safe(mode, m, &connector->probed_modes, head) {
> +		mode->clock >>= 1;
> +		mode->hdisplay >>= 1;
> +		mode->hsync_start >>= 1;
> +		mode->hsync_end >>= 1;
> +		mode->htotal >>= 1;
> +		drm_mode_set_name(mode);
> +	}
> +}
> +
> +static int dsi_dual_connector_tile_init(
> +			struct drm_connector *connector, int id)
> +{
> +	struct drm_display_mode *mode;
> +	/* Fake topology id */
> +	char topo_id[8] = {'M', 'S', 'M', 'D', 'U', 'D', 'S', 'I'};
> +
> +	/* Use the first mode only for now */
> +	mode = list_first_entry(&connector->probed_modes,
> +				struct drm_display_mode,
> +				head);
> +	if (!mode)
> +		return -EINVAL;
> +
> +	connector->has_tile = true;
> +	connector->tile_group = drm_mode_get_tile_group(
> +					connector->dev, topo_id);
> +	if (!connector->tile_group)
> +		connector->tile_group = drm_mode_create_tile_group(
> +					connector->dev, topo_id);
> +	if (!connector->tile_group) {
> +		pr_err("%s: failed to create tile group\n", __func__);
> +		return -ENOMEM;
> +	}
> +
> +	connector->tile_is_single_monitor = true;
> +
> +	/* mode has been fixed */
> +	connector->tile_h_size = mode->hdisplay;
> +	connector->tile_v_size = mode->vdisplay;
> +
> +	/* Only support left-right mode */
> +	connector->num_h_tile = 2;
> +	connector->num_v_tile = 1;
> +
> +	connector->tile_v_loc = 0;
> +	connector->tile_h_loc = (id == DSI_RIGHT) ? 1 : 0;
> +
> +	return 0;
> +}
> +
> +static int dsi_mgr_connector_get_modes(struct drm_connector *connector)
> +{
> +	int id = dsi_mgr_connector_get_id(connector);
> +	struct msm_dsi *msm_dsi = dsi_mgr_get_dsi(id);
> +	struct drm_panel *panel = msm_dsi->panel;
> +	int ret, num;
> +
> +	if (!panel)
> +		return 0;
> +
> +	/* Since we have 2 connectors, but only 1 drm_panel in dual DSI mode,
> +	 * panel should not attach to any connector.
> +	 * Only temporarily attach panel to the current connector here,
> +	 * to let panel set mode to this connector.
> +	 */
> +	drm_panel_attach(panel, connector);
> +	num = drm_panel_get_modes(panel);
> +	drm_panel_detach(panel);
> +	if (!num)
> +		return 0;
> +
> +	if (IS_DUAL_PANEL()) {
> +		/* report half resolution to user */
> +		dsi_dual_connector_fix_modes(connector);
> +		ret = dsi_dual_connector_tile_init(connector, id);
> +		if (ret)
> +			return ret;
> +		ret = drm_mode_connector_set_tile_property(connector);
> +		if (ret) {
> +			pr_err("%s: set tile property failed, %d\n",
> +					__func__, ret);
> +			return ret;
> +		}
> +	}
> +
> +	return num;
> +}
> +
> +static int dsi_mgr_connector_mode_valid(struct drm_connector *connector,
> +				struct drm_display_mode *mode)
> +{
> +	int id = dsi_mgr_connector_get_id(connector);
> +	struct msm_dsi *msm_dsi = dsi_mgr_get_dsi(id);
> +	struct drm_encoder *encoder =
> +		(msm_dsi->panel_flags & MIPI_DSI_MODE_VIDEO) ?
> +		msm_dsi->base.encoders[MSM_DSI_VIDEO_ENCODER_ID] :
> +		msm_dsi->base.encoders[MSM_DSI_CMD_ENCODER_ID];

Maybe you could make a helper 'msm_dsi_get_encoder(msm_dsi)' out of 
this? It seems to be used elsewhere too.

> +	struct msm_drm_private *priv = connector->dev->dev_private;
> +	struct msm_kms *kms = priv->kms;
> +	long actual, requested;
> +
> +	DBG("");
> +	requested = 1000 * mode->clock;
> +	actual = kms->funcs->round_pixclk(kms, requested, encoder);
> +
> +	DBG("requested=%ld, actual=%ld", requested, actual);
> +	if (actual != requested)
> +		return MODE_CLOCK_RANGE;
> +
> +	return MODE_OK;
> +}
> +
> +static struct drm_encoder *
> +dsi_mgr_connector_best_encoder(struct drm_connector *connector)
> +{
> +	int id = dsi_mgr_connector_get_id(connector);
> +	struct msm_dsi *msm_dsi = dsi_mgr_get_dsi(id);
> +
> +	DBG("");
> +	return (msm_dsi->panel_flags & MIPI_DSI_MODE_VIDEO) ?
> +		msm_dsi->base.encoders[MSM_DSI_VIDEO_ENCODER_ID] :
> +		msm_dsi->base.encoders[MSM_DSI_CMD_ENCODER_ID];
> +}
> +
> +static void dsi_mgr_bridge_pre_enable(struct drm_bridge *bridge)
> +{
> +	int id = dsi_mgr_bridge_get_id(bridge);
> +	struct msm_dsi *msm_dsi = dsi_mgr_get_dsi(id);
> +	struct msm_dsi *msm_dsi1 = dsi_mgr_get_dsi(DSI_1);
> +	struct mipi_dsi_host *host = msm_dsi->host;
> +	struct drm_panel *panel = msm_dsi->panel;
> +	bool is_dual_panel = IS_DUAL_PANEL();
> +	int ret;
> +
> +	DBG("id=%d", id);
> +	if (!panel || (is_dual_panel && (DSI_1 == id)))
> +		return;
> +
> +	ret = msm_dsi_host_power_on(host);
> +	if (ret) {
> +		pr_err("%s: power on host %d failed, %d\n", __func__, id, ret);
> +		goto host_on_fail;
> +	}
> +
> +	if (is_dual_panel && msm_dsi1) {
> +		ret = msm_dsi_host_power_on(msm_dsi1->host);
> +		if (ret) {
> +			pr_err("%s: power on host1 failed, %d\n",
> +							__func__, ret);
> +			goto host1_on_fail;
> +		}
> +	}
> +
> +	/* Always call panel functions once, because even for dual panels,
> +	 * there is only one drm_panel instance.
> +	 */
> +	ret = drm_panel_prepare(panel);
> +	if (ret) {
> +		pr_err("%s: prepare panel %d failed, %d\n", __func__, id, ret);
> +		goto panel_prep_fail;
> +	}
> +
> +	ret = msm_dsi_host_enable(host);
> +	if (ret) {
> +		pr_err("%s: enable host %d failed, %d\n", __func__, id, ret);
> +		goto host_en_fail;
> +	}
> +
> +	if (is_dual_panel && msm_dsi1) {
> +		ret = msm_dsi_host_enable(msm_dsi1->host);
> +		if (ret) {
> +			pr_err("%s: enable host1 failed, %d\n", __func__, ret);
> +			goto host1_en_fail;
> +		}
> +	}
> +
> +	ret = drm_panel_enable(panel);
> +	if (ret) {
> +		pr_err("%s: enable panel %d failed, %d\n", __func__, id, ret);
> +		goto panel_en_fail;
> +	}
> +
> +	return;
> +
> +panel_en_fail:
> +	if (is_dual_panel && msm_dsi1)
> +		msm_dsi_host_disable(msm_dsi1->host);
> +host1_en_fail:
> +	msm_dsi_host_disable(host);
> +host_en_fail:
> +	drm_panel_unprepare(panel);
> +panel_prep_fail:
> +	if (is_dual_panel && msm_dsi1)
> +		msm_dsi_host_power_off(msm_dsi1->host);
> +host1_on_fail:
> +	msm_dsi_host_power_off(host);
> +host_on_fail:
> +	return;
> +}
> +
> +static void dsi_mgr_bridge_enable(struct drm_bridge *bridge)
> +{
> +	DBG("");
> +}
> +
> +static void dsi_mgr_bridge_disable(struct drm_bridge *bridge)
> +{
> +	DBG("");
> +}
> +
> +static void dsi_mgr_bridge_post_disable(struct drm_bridge *bridge)
> +{
> +	int id = dsi_mgr_bridge_get_id(bridge);
> +	struct msm_dsi *msm_dsi = dsi_mgr_get_dsi(id);
> +	struct msm_dsi *msm_dsi1 = dsi_mgr_get_dsi(DSI_1);
> +	struct mipi_dsi_host *host = msm_dsi->host;
> +	struct drm_panel *panel = msm_dsi->panel;
> +	bool is_dual_panel = IS_DUAL_PANEL();
> +	int ret;
> +
> +	DBG("id=%d", id);
> +
> +	if (!panel || (is_dual_panel && (DSI_1 == id)))
> +		return;
> +
> +	ret = drm_panel_disable(panel);
> +	if (ret)
> +		pr_err("%s: Panel %d OFF failed, %d\n", __func__, id, ret);
> +
> +	ret = msm_dsi_host_disable(host);
> +	if (ret)
> +		pr_err("%s: host %d disable failed, %d\n", __func__, id, ret);
> +
> +	if (is_dual_panel && msm_dsi1) {
> +		ret = msm_dsi_host_disable(msm_dsi1->host);
> +		if (ret)
> +			pr_err("%s: host1 disable failed, %d\n", __func__, ret);
> +	}
> +
> +	ret = drm_panel_unprepare(panel);
> +	if (ret)
> +		pr_err("%s: Panel %d unprepare failed,%d\n", __func__, id, ret);
> +
> +	ret = msm_dsi_host_power_off(host);
> +	if (ret)
> +		pr_err("%s: host %d power off failed,%d\n", __func__, id, ret);
> +
> +	if (is_dual_panel && msm_dsi1) {
> +		ret = msm_dsi_host_power_off(msm_dsi1->host);
> +		if (ret)
> +			pr_err("%s: host1 power off failed, %d\n",
> +								__func__, ret);
> +	}
> +}
> +
> +static void dsi_mgr_bridge_mode_set(struct drm_bridge *bridge,
> +		struct drm_display_mode *mode,
> +		struct drm_display_mode *adjusted_mode)
> +{
> +	int id = dsi_mgr_bridge_get_id(bridge);
> +	struct msm_dsi *msm_dsi = dsi_mgr_get_dsi(id);
> +	struct msm_dsi *other_dsi = dsi_mgr_get_other_dsi(id);
> +	struct mipi_dsi_host *host = msm_dsi->host;
> +	bool is_dual_panel = IS_DUAL_PANEL();
> +
> +	DBG("set mode: %d:\"%s\" %d %d %d %d %d %d %d %d %d %d 0x%x 0x%x",
> +			mode->base.id, mode->name,
> +			mode->vrefresh, mode->clock,
> +			mode->hdisplay, mode->hsync_start,
> +			mode->hsync_end, mode->htotal,
> +			mode->vdisplay, mode->vsync_start,
> +			mode->vsync_end, mode->vtotal,
> +			mode->type, mode->flags);
> +
> +	if (is_dual_panel && (DSI_1 == id))
> +		return;
> +
> +	msm_dsi_host_set_display_mode(host, adjusted_mode);
> +	if (is_dual_panel && other_dsi)
> +		msm_dsi_host_set_display_mode(other_dsi->host, adjusted_mode);
> +}
> +
> +static const struct drm_connector_funcs dsi_mgr_connector_funcs = {
> +	.dpms = drm_atomic_helper_connector_dpms,
> +	.detect = dsi_mgr_connector_detect,
> +	.fill_modes = drm_helper_probe_single_connector_modes,
> +	.destroy = dsi_mgr_connector_destroy,
> +	.reset = drm_atomic_helper_connector_reset,
> +	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
> +	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
> +};
> +
> +static const struct drm_connector_helper_funcs dsi_mgr_conn_helper_funcs = {
> +	.get_modes = dsi_mgr_connector_get_modes,
> +	.mode_valid = dsi_mgr_connector_mode_valid,
> +	.best_encoder = dsi_mgr_connector_best_encoder,
> +};
> +
> +static const struct drm_bridge_funcs dsi_mgr_bridge_funcs = {
> +	.pre_enable = dsi_mgr_bridge_pre_enable,
> +	.enable = dsi_mgr_bridge_enable,
> +	.disable = dsi_mgr_bridge_disable,
> +	.post_disable = dsi_mgr_bridge_post_disable,
> +	.mode_set = dsi_mgr_bridge_mode_set,
> +};
> +
> +/* initialize connector */
> +struct drm_connector *msm_dsi_manager_connector_init(u8 id)
> +{
> +	struct msm_dsi *msm_dsi = dsi_mgr_get_dsi(id);
> +	struct drm_connector *connector = NULL;
> +	struct dsi_connector *dsi_connector;
> +	int ret;
> +
> +	dsi_connector = devm_kzalloc(msm_dsi->dev->dev,
> +				sizeof(*dsi_connector), GFP_KERNEL);
> +	if (!dsi_connector) {
> +		ret = -ENOMEM;
> +		goto fail;
> +	}
> +
> +	dsi_connector->id = id;
> +
> +	connector = &dsi_connector->base;
> +
> +	ret = drm_connector_init(msm_dsi->dev, connector,
> +			&dsi_mgr_connector_funcs, DRM_MODE_CONNECTOR_DSI);
> +	if (ret)
> +		goto fail;
> +
> +	drm_connector_helper_add(connector, &dsi_mgr_conn_helper_funcs);
> +
> +	/* Enable HPD to let hpd event is handled
> +	 * when panel is attached to the host.
> +	 */
> +	connector->polled = DRM_CONNECTOR_POLL_HPD;
> +
> +	/* Display driver doesn't support interlace now. */
> +	connector->interlace_allowed = 0;
> +	connector->doublescan_allowed = 0;
> +
> +	ret = drm_connector_register(connector);
> +	if (ret)
> +		goto fail;
> +
> +	return connector;
> +
> +fail:
> +	if (connector)
> +		dsi_mgr_connector_destroy(connector);
> +
> +	return ERR_PTR(ret);
> +}
> +
> +/* initialize bridge */
> +struct drm_bridge *msm_dsi_manager_bridge_init(u8 id)
> +{
> +	struct msm_dsi *msm_dsi = dsi_mgr_get_dsi(id);
> +	struct drm_bridge *bridge = NULL;
> +	struct dsi_bridge *dsi_bridge;
> +	int ret;
> +
> +	dsi_bridge = devm_kzalloc(msm_dsi->dev->dev,
> +				sizeof(*dsi_bridge), GFP_KERNEL);
> +	if (!dsi_bridge) {
> +		ret = -ENOMEM;
> +		goto fail;
> +	}
> +
> +	dsi_bridge->id = id;
> +
> +	bridge = &dsi_bridge->base;
> +	bridge->funcs = &dsi_mgr_bridge_funcs;
> +
> +	ret = drm_bridge_attach(msm_dsi->dev, bridge);
> +	if (ret)
> +		goto fail;
> +
> +	return bridge;
> +
> +fail:
> +	if (bridge)
> +		msm_dsi_manager_bridge_destroy(bridge);
> +
> +	return ERR_PTR(ret);
> +}
> +
> +void msm_dsi_manager_bridge_destroy(struct drm_bridge *bridge)
> +{
> +}
> +
> +int msm_dsi_manager_phy_enable(int id,
> +		const unsigned long bit_rate, const unsigned long esc_rate,
> +		u32 *clk_pre, u32 *clk_post)
> +{
> +	struct msm_dsi *msm_dsi = dsi_mgr_get_dsi(id);
> +	struct msm_dsi_phy *phy = msm_dsi->phy;
> +	int ret;
> +
> +	ret = msm_dsi_phy_enable(phy, IS_DUAL_PANEL(), bit_rate, esc_rate);
> +	if (ret)
> +		return ret;
> +
> +	msm_dsi->phy_enabled = true;
> +	msm_dsi_phy_get_clk_pre_post(phy, clk_pre, clk_post);
> +
> +	return 0;
> +}
> +
> +void msm_dsi_manager_phy_disable(int id)
> +{
> +	struct msm_dsi *msm_dsi = dsi_mgr_get_dsi(id);
> +	struct msm_dsi *mdsi = dsi_mgr_get_dsi(DSI_CLOCK_MASTER);
> +	struct msm_dsi *sdsi = dsi_mgr_get_dsi(DSI_CLOCK_SLAVE);
> +	struct msm_dsi_phy *phy = msm_dsi->phy;
> +
> +	/* disable DSI phy
> +	 * In dual-dsi configuration, the phy should be disabled for the
> +	 * first controller only when the second controller is disabled.
> +	 */
> +	msm_dsi->phy_enabled = false;
> +	if (IS_DUAL_PANEL() && mdsi && sdsi) {
> +		if (!mdsi->phy_enabled && !sdsi->phy_enabled) {
> +			msm_dsi_phy_disable(sdsi->phy);
> +			msm_dsi_phy_disable(mdsi->phy);
> +		}
> +	} else {
> +		msm_dsi_phy_disable(phy);
> +	}
> +}
> +
> +int msm_dsi_manager_cmd_xfer(int id, const struct mipi_dsi_msg *msg)
> +{
> +	struct msm_dsi *msm_dsi = dsi_mgr_get_dsi(id);
> +	struct msm_dsi *msm_dsi0 = dsi_mgr_get_dsi(DSI_0);
> +	struct mipi_dsi_host *host = msm_dsi->host;
> +	bool is_read = (msg->rx_buf && msg->rx_len);
> +	bool need_sync = (IS_SYNC_NEEDED() && !is_read);
> +	int ret;
> +
> +	if (!msg->tx_buf || !msg->tx_len)
> +		return 0;
> +
> +	/* In dual master case, panel requires the same commands sent to
> +	 * both DSI links. Host issues the command trigger to both links
> +	 * when DSI_1 calls the cmd transfer function, no matter it happens
> +	 * before or after DSI_0 cmd transfer.
> +	 */
> +	if (need_sync && (id == DSI_0))
> +		return is_read ? msg->rx_len : msg->tx_len;
> +
> +	if (need_sync && msm_dsi0) {
> +		ret = msm_dsi_host_xfer_prepare(msm_dsi0->host, msg);
> +		if (ret) {
> +			pr_err("%s: failed to prepare non-trigger host, %d\n",
> +				__func__, ret);
> +			return ret;
> +		}
> +	}
> +	ret = msm_dsi_host_xfer_prepare(host, msg);
> +	if (ret) {
> +		pr_err("%s: failed to prepare host, %d\n", __func__, ret);
> +		goto restore_host0;
> +	}
> +
> +	ret = is_read ? msm_dsi_host_cmd_rx(host, msg) :
> +			msm_dsi_host_cmd_tx(host, msg);
> +
> +	msm_dsi_host_xfer_restore(host, msg);
> +
> +restore_host0:
> +	if (need_sync && msm_dsi0)
> +		msm_dsi_host_xfer_restore(msm_dsi0->host, msg);
> +
> +	return ret;
> +}
> +
> +bool msm_dsi_manager_cmd_xfer_trigger(int id, u32 iova, u32 len)
> +{
> +	struct msm_dsi *msm_dsi = dsi_mgr_get_dsi(id);
> +	struct msm_dsi *msm_dsi0 = dsi_mgr_get_dsi(DSI_0);
> +	struct mipi_dsi_host *host = msm_dsi->host;
> +
> +	if (IS_SYNC_NEEDED() && (id == DSI_0))
> +		return false;
> +
> +	if (IS_SYNC_NEEDED() && msm_dsi0)
> +		msm_dsi_host_cmd_xfer_commit(msm_dsi0->host, iova, len);
> +
> +	msm_dsi_host_cmd_xfer_commit(host, iova, len);
> +
> +	return true;
> +}
> +
> +int msm_dsi_manager_register(struct msm_dsi *msm_dsi)
> +{
> +	struct msm_dsi_manager *msm_dsim = &msm_dsim_glb;
> +	int id = msm_dsi->id;
> +	struct msm_dsi *other_dsi = dsi_mgr_get_other_dsi(id);
> +	int ret;
> +
> +	if (id > DSI_MAX) {
> +		pr_err("%s: invalid id %d\n", __func__, id);
> +		return -EINVAL;
> +	}
> +
> +	if (msm_dsim->dsi[id]) {
> +		pr_err("%s: dsi%d already registered\n", __func__, id);
> +		return -EBUSY;
> +	}
> +
> +	msm_dsim->dsi[id] = msm_dsi;
> +
> +	ret = dsi_mgr_parse_dual_panel(msm_dsi->pdev->dev.of_node, id);
> +	if (ret) {
> +		pr_err("%s: failed to parse dual panel info\n", __func__);
> +		return ret;
> +	}
> +
> +	if (!IS_DUAL_PANEL()) {
> +		ret = msm_dsi_host_register(msm_dsi->host, true);
> +	} else if (!other_dsi) {
> +		return 0;
> +	} else {
> +		struct msm_dsi *mdsi = IS_MASTER_PANEL(id) ?
> +					msm_dsi : other_dsi;
> +		struct msm_dsi *sdsi = IS_MASTER_PANEL(id) ?
> +					other_dsi : msm_dsi;
> +		/* Register slave host first, so that slave DSI device
> +		 * has a chance to probe, and do not block the master
> +		 * DSI device's probe.
> +		 * Also, do not check defer for the slave host,
> +		 * because only master DSI device adds the panel to global
> +		 * panel list. The panel's device is the master DSI device.
> +		 */
> +		ret = msm_dsi_host_register(sdsi->host, false);
> +		if (ret)
> +			return ret;
> +		ret = msm_dsi_host_register(mdsi->host, true);
> +	}
> +
> +	return ret;
> +}

The dual panel checks in these functions are quite intrusive at the 
moment. We'd use DSI later where there won't be a panel at all. That 
would result in ever more complicated checks.

Is it possible to separate out the dual panel functionality such that it 
becomes cleaner?

For example msm_dsi_manager_phy_disable can look like:

void msm_dsi_manager_phy_disable(int id)
{
	...
	...

	if (msm_dual_dsi_mode())
		msm_dual_dsi_phy_disable(id);
	else
		msm_dsi_phy_disable(phy);

	...
}

There might be repetition of some code between the normal and dual mode 
case, but it will make things quite legible.

> +
> +void msm_dsi_manager_unregister(struct msm_dsi *msm_dsi)
> +{
> +	struct msm_dsi_manager *msm_dsim = &msm_dsim_glb;
> +
> +	msm_dsi_host_unregister(msm_dsi->host);
> +	msm_dsim->dsi[msm_dsi->id] = NULL;
> +}
> +
> diff --git a/drivers/gpu/drm/msm/dsi/dsi_phy.c b/drivers/gpu/drm/msm/dsi/dsi_phy.c
> new file mode 100644
> index 0000000..f0cea89
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dsi/dsi_phy.c
> @@ -0,0 +1,352 @@
> +/*
> + * Copyright (c) 2015, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + */
> +
> +#include "dsi.h"
> +#include "dsi.xml.h"I
> +
> +#define dsi_phy_read(offset) msm_readl((offset))
> +#define dsi_phy_write(offset, data) msm_writel((data), (offset))
> +
> +struct dsi_dphy_timing {
> +	u32 clk_pre;
> +	u32 clk_post;
> +	u32 clk_zero;
> +	u32 clk_trail;
> +	u32 clk_prepare;
> +	u32 hs_exit;
> +	u32 hs_zero;
> +	u32 hs_prepare;
> +	u32 hs_trail;
> +	u32 hs_rqst;
> +	u32 ta_go;
> +	u32 ta_sure;
> +	u32 ta_get;
> +};
> +
> +struct msm_dsi_phy {
> +	void __iomem *base;
> +	void __iomem *reg_base;
> +	int id;
> +	struct dsi_dphy_timing timing;
> +	int (*enable)(struct msm_dsi_phy *phy, bool is_dual_panel,
> +		const unsigned long bit_rate, const unsigned long esc_rate);
> +	int (*disable)(struct msm_dsi_phy *phy);
> +};
> +
> +#define S_DIV_ROUND_UP(n, d)	\
> +	(((n) >= 0) ? (((n) + (d) - 1) / (d)) : (((n) - (d) + 1) / (d)))
> +
> +static inline s32 linear_inter(s32 tmax, s32 tmin, s32 percent,
> +				s32 min_result, bool even)
> +{
> +	s32 v;
> +	v = (tmax - tmin) * percent;
> +	v = S_DIV_ROUND_UP(v, 100) + tmin;
> +	if (even && (v & 0x1))
> +		return max_t(s32, min_result, v - 1);
> +	else
> +		return max_t(s32, min_result, v);
> +}
> +
> +static void dsi_dphy_timing_calc_clk_zero(struct dsi_dphy_timing *timing,
> +					s32 ui, s32 coeff, s32 pcnt)
> +{
> +	s32 tmax, tmin, clk_z;
> +	s32 temp;
> +
> +	/* reset */
> +	temp = 300 * coeff - ((timing->clk_prepare >> 1) + 1) * 2 * ui;
> +	tmin = S_DIV_ROUND_UP(temp, ui) - 2;
> +	if (tmin > 255) {
> +		tmax = 511;
> +		clk_z = linear_inter(2 * tmin, tmin, pcnt, 0, true);
> +	} else {
> +		tmax = 255;
> +		clk_z = linear_inter(tmax, tmin, pcnt, 0, true);
> +	}
> +
> +	/* adjust */
> +	temp = (timing->hs_rqst + timing->clk_prepare + clk_z) & 0x7;
> +	timing->clk_zero = clk_z + 8 - temp;
> +}
> +
> +static int dsi_dphy_timing_calc(struct dsi_dphy_timing *timing,
> +	const unsigned long bit_rate, const unsigned long esc_rate)
> +{
> +	s32 ui, lpx;
> +	s32 tmax, tmin;
> +	s32 pcnt0 = 10;
> +	s32 pcnt1 = (bit_rate > 1200000000) ? 15 : 10;
> +	s32 pcnt2 = 10;
> +	s32 pcnt3 = (bit_rate > 180000000) ? 10 : 40;
> +	s32 coeff = 1000; /* Precision, should avoid overflow */
> +	s32 temp;
> +
> +	if (!bit_rate || !esc_rate)
> +		return -EINVAL;
> +
> +	ui = mult_frac(NSEC_PER_MSEC, coeff, bit_rate / 1000);
> +	lpx = mult_frac(NSEC_PER_MSEC, coeff, esc_rate / 1000);
> +
> +	tmax = S_DIV_ROUND_UP(95 * coeff, ui) - 2;
> +	tmin = S_DIV_ROUND_UP(38 * coeff, ui) - 2;
> +	timing->clk_prepare = linear_inter(tmax, tmin, pcnt0, 0, true);
> +
> +	temp = lpx / ui;
> +	if (temp & 0x1)
> +		timing->hs_rqst = temp;
> +	else
> +		timing->hs_rqst = max_t(s32, 0, temp - 2);
> +
> +	/* Calculate clk_zero after clk_prepare and hs_rqst */
> +	dsi_dphy_timing_calc_clk_zero(timing, ui, coeff, pcnt2);
> +
> +	temp = 105 * coeff + 12 * ui - 20 * coeff;
> +	tmax = S_DIV_ROUND_UP(temp, ui) - 2;
> +	tmin = S_DIV_ROUND_UP(60 * coeff, ui) - 2;
> +	timing->clk_trail = linear_inter(tmax, tmin, pcnt3, 0, true);
> +
> +	temp = 85 * coeff + 6 * ui;
> +	tmax = S_DIV_ROUND_UP(temp, ui) - 2;
> +	temp = 40 * coeff + 4 * ui;
> +	tmin = S_DIV_ROUND_UP(temp, ui) - 2;
> +	timing->hs_prepare = linear_inter(tmax, tmin, pcnt1, 0, true);
> +
> +	tmax = 255;
> +	temp = ((timing->hs_prepare >> 1) + 1) * 2 * ui + 2 * ui;
> +	temp = 145 * coeff + 10 * ui - temp;
> +	tmin = S_DIV_ROUND_UP(temp, ui) - 2;
> +	timing->hs_zero = linear_inter(tmax, tmin, pcnt2, 24, true);
> +
> +	temp = 105 * coeff + 12 * ui - 20 * coeff;
> +	tmax = S_DIV_ROUND_UP(temp, ui) - 2;
> +	temp = 60 * coeff + 4 * ui;
> +	tmin = DIV_ROUND_UP(temp, ui) - 2;
> +	timing->hs_trail = linear_inter(tmax, tmin, pcnt3, 0, true);
> +
> +	tmax = 255;
> +	tmin = S_DIV_ROUND_UP(100 * coeff, ui) - 2;
> +	timing->hs_exit = linear_inter(tmax, tmin, pcnt2, 0, true);
> +
> +	tmax = 63;
> +	temp = ((timing->hs_exit >> 1) + 1) * 2 * ui;
> +	temp = 60 * coeff + 52 * ui - 24 * ui - temp;
> +	tmin = S_DIV_ROUND_UP(temp, 8 * ui) - 1;
> +	timing->clk_post = linear_inter(tmax, tmin, pcnt2, 0, false);
> +
> +	tmax = 63;
> +	temp = ((timing->clk_prepare >> 1) + 1) * 2 * ui;
> +	temp += ((timing->clk_zero >> 1) + 1) * 2 * ui;
> +	temp += 8 * ui + lpx;
> +	tmin = S_DIV_ROUND_UP(temp, 8 * ui) - 1;
> +	if (tmin > tmax) {
> +		temp = linear_inter(2 * tmax, tmin, pcnt2, 0, false) >> 1;
> +		timing->clk_pre = temp >> 1;
> +		temp = (2 * tmax - tmin) * pcnt2;
> +	} else {
> +		timing->clk_pre = linear_inter(tmax, tmin, pcnt2, 0, false);
> +	}
> +
> +	timing->ta_go = 3;
> +	timing->ta_sure = 0;
> +	timing->ta_get = 4;
> +
> +	DBG("PHY timings: %d, %d, %d, %d, %d, %d, %d, %d, %d, %d",
> +		timing->clk_pre, timing->clk_post, timing->clk_zero,
> +		timing->clk_trail, timing->clk_prepare, timing->hs_exit,
> +		timing->hs_zero, timing->hs_prepare, timing->hs_trail,
> +		timing->hs_rqst);
> +
> +	return 0;
> +}
> +
> +static void dsi_28nm_phy_regulator_ctrl(struct msm_dsi_phy *phy, bool enable)
> +{
> +	void __iomem *base = phy->reg_base;
> +
> +	if (!enable) {
> +		dsi_phy_write(base + REG_DSI_28nm_PHY_REGULATOR_CAL_PWR_CFG, 0);
> +		return;
> +	}
> +
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_REGULATOR_CTRL_0, 0x0);
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_REGULATOR_CAL_PWR_CFG, 1);
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_REGULATOR_CTRL_5, 0);
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_REGULATOR_CTRL_3, 0);
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_REGULATOR_CTRL_2, 0x3);
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_REGULATOR_CTRL_1, 0x9);
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_REGULATOR_CTRL_0, 0x7);
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_REGULATOR_CTRL_4, 0x20);
> +}
> +
> +static int dsi_28nm_phy_enable(struct msm_dsi_phy *phy, bool is_dual_panel,
> +		const unsigned long bit_rate, const unsigned long esc_rate)
> +{
> +	struct dsi_dphy_timing *timing = &phy->timing;
> +	int i;
> +	void __iomem *base = phy->base;
> +
> +	DBG("");
> +
> +	if (dsi_dphy_timing_calc(timing, bit_rate, esc_rate)) {
> +		pr_err("%s: D-PHY timing calculation failed\n", __func__);
> +		return -EINVAL;
> +	}
> +
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_STRENGTH_0, 0xff);
> +
> +	dsi_28nm_phy_regulator_ctrl(phy, true);
> +
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_LDO_CNTRL, 0x00);
> +
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_TIMING_CTRL_0,
> +		DSI_28nm_PHY_TIMING_CTRL_0_CLK_ZERO(timing->clk_zero));
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_TIMING_CTRL_1,
> +		DSI_28nm_PHY_TIMING_CTRL_1_CLK_TRAIL(timing->clk_trail));
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_TIMING_CTRL_2,
> +		DSI_28nm_PHY_TIMING_CTRL_2_CLK_PREPARE(timing->clk_prepare));
> +	if (timing->clk_zero & BIT(8))
> +		dsi_phy_write(base + REG_DSI_28nm_PHY_TIMING_CTRL_3,
> +			DSI_28nm_PHY_TIMING_CTRL_3_CLK_ZERO_8);
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_TIMING_CTRL_4,
> +		DSI_28nm_PHY_TIMING_CTRL_4_HS_EXIT(timing->hs_exit));
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_TIMING_CTRL_5,
> +		DSI_28nm_PHY_TIMING_CTRL_5_HS_ZERO(timing->hs_zero));
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_TIMING_CTRL_6,
> +		DSI_28nm_PHY_TIMING_CTRL_6_HS_PREPARE(timing->hs_prepare));
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_TIMING_CTRL_7,
> +		DSI_28nm_PHY_TIMING_CTRL_7_HS_TRAIL(timing->hs_trail));
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_TIMING_CTRL_8,
> +		DSI_28nm_PHY_TIMING_CTRL_8_HS_RQST(timing->hs_rqst));
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_TIMING_CTRL_9,
> +		DSI_28nm_PHY_TIMING_CTRL_9_TA_GO(timing->ta_go) |
> +		DSI_28nm_PHY_TIMING_CTRL_9_TA_SURE(timing->ta_sure));
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_TIMING_CTRL_10,
> +		DSI_28nm_PHY_TIMING_CTRL_10_TA_GET(timing->ta_get));
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_TIMING_CTRL_11,
> +		DSI_28nm_PHY_TIMING_CTRL_11_TRIG3_CMD(0));
> +
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_CTRL_1, 0x00);
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_CTRL_0, 0x5f);
> +
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_STRENGTH_1, 0x6);
> +
> +	for (i = 0; i < 4; i++) {
> +		dsi_phy_write(base + REG_DSI_28nm_PHY_LN_CFG_0(i), 0);
> +		dsi_phy_write(base + REG_DSI_28nm_PHY_LN_CFG_1(i), 0);
> +		dsi_phy_write(base + REG_DSI_28nm_PHY_LN_CFG_2(i), 0);
> +		dsi_phy_write(base + REG_DSI_28nm_PHY_LN_CFG_3(i), 0);
> +		dsi_phy_write(base + REG_DSI_28nm_PHY_LN_TEST_DATAPATH(i), 0);
> +		dsi_phy_write(base + REG_DSI_28nm_PHY_LN_DEBUG_SEL(i), 0);
> +		dsi_phy_write(base + REG_DSI_28nm_PHY_LN_TEST_STR_0(i), 0x1);
> +		dsi_phy_write(base + REG_DSI_28nm_PHY_LN_TEST_STR_1(i), 0x97);
> +	}
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_LN_CFG_4(0), 0);
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_LN_CFG_4(1), 0x5);
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_LN_CFG_4(2), 0xa);
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_LN_CFG_4(3), 0xf);
> +
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_LNCK_CFG_1, 0xc0);
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_LNCK_TEST_STR0, 0x1);
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_LNCK_TEST_STR1, 0xbb);
> +
> +	dsi_phy_write(base + REG_DSI_28nm_PHY_CTRL_0, 0x5f);
> +
> +	if (is_dual_panel && (phy->id != DSI_CLOCK_MASTER))
> +		dsi_phy_write(base + REG_DSI_28nm_PHY_GLBL_TEST_CTRL, 0x00);
> +	else
> +		dsi_phy_write(base + REG_DSI_28nm_PHY_GLBL_TEST_CTRL, 0x01);
> +
> +	return 0;
> +}
> +
> +static int dsi_28nm_phy_disable(struct msm_dsi_phy *phy)
> +{
> +	dsi_phy_write(phy->base + REG_DSI_28nm_PHY_CTRL_0, 0);
> +	dsi_28nm_phy_regulator_ctrl(phy, false);
> +
> +	/*
> +	 * Wait for the registers writes to complete in order to
> +	 * ensure that the phy is completely disabled
> +	 */
> +	wmb();
> +
> +	return 0;
> +}
> +
> +#define dsi_phy_func_init(name)	\
> +	do {	\
> +		phy->enable = dsi_##name##_phy_enable;	\
> +		phy->disable = dsi_##name##_phy_disable;	\
> +	} while (0)
> +
> +struct msm_dsi_phy *msm_dsi_phy_init(struct platform_device *pdev,
> +			enum msm_dsi_phy_type type, int id)
> +{
> +	struct msm_dsi_phy *phy;
> +
> +	phy = devm_kzalloc(&pdev->dev, sizeof(*phy), GFP_KERNEL);
> +	if (!phy)
> +		return NULL;
> +
> +	phy->base = msm_ioremap(pdev, "dsi_phy", "DSI_PHY");
> +	if (IS_ERR_OR_NULL(phy->base)) {
> +		pr_err("%s: failed to map phy base\n", __func__);
> +		return NULL;
> +	}
> +	phy->reg_base = msm_ioremap(pdev, "dsi_phy_regulator", "DSI_PHY_REG");
> +	if (IS_ERR_OR_NULL(phy->reg_base)) {
> +		pr_err("%s: failed to map phy regulator base\n", __func__);
> +		return NULL;
> +	}
> +
> +	switch (type) {
> +	case MSM_DSI_PHY_28NM:
> +		dsi_phy_func_init(28nm);
> +		break;
> +	default:
> +		pr_err("%s: unsupported type, %d\n", __func__, type);
> +		return NULL;
> +	}
> +
> +	phy->id = id;
> +
> +	return phy;
> +}
> +
> +int msm_dsi_phy_enable(struct msm_dsi_phy *phy, bool is_dual_panel,
> +	const unsigned long bit_rate, const unsigned long esc_rate)
> +{
> +	if (!phy || !phy->enable)
> +		return -EINVAL;
> +	return phy->enable(phy, is_dual_panel, bit_rate, esc_rate);
> +}
> +
> +int msm_dsi_phy_disable(struct msm_dsi_phy *phy)
> +{
> +	if (!phy || !phy->disable)
> +		return -EINVAL;
> +	return phy->disable(phy);
> +}
> +
> +void msm_dsi_phy_get_clk_pre_post(struct msm_dsi_phy *phy,
> +	u32 *clk_pre, u32 *clk_post)
> +{
> +	if (!phy)
> +		return;
> +	if (clk_pre)
> +		*clk_pre = phy->timing.clk_pre;
> +	if (clk_post)
> +		*clk_post = phy->timing.clk_post;
> +}
> +
> diff --git a/drivers/gpu/drm/msm/msm_drv.h b/drivers/gpu/drm/msm/msm_drv.h
> index 7b464db..a18683f 100644
> --- a/drivers/gpu/drm/msm/msm_drv.h
> +++ b/drivers/gpu/drm/msm/msm_drv.h
> @@ -95,6 +95,9 @@ struct msm_drm_private {
>   	 */
>   	struct msm_drm_sub_dev *edp;
>
> +	/* DSI is shared by mdp4 and mdp5 */
> +	struct msm_drm_sub_dev *dsi[2];
> +
>   	/* when we have more than one 'msm_gpu' these need to be an array: */
>   	struct msm_gpu *gpu;
>   	struct msm_file_private *lastctx;
> @@ -243,6 +246,23 @@ void __exit hdmi_unregister(void);
>   void __init msm_edp_register(void);
>   void __exit msm_edp_unregister(void);
>
> +enum msm_dsi_encoder_id {
> +	MSM_DSI_VIDEO_ENCODER_ID = 0,
> +	MSM_DSI_CMD_ENCODER_ID = 1,
> +	MSM_DSI_ENCODER_NUM = 2
> +};
> +#ifdef CONFIG_DRM_MSM_DSI
> +void __init msm_dsi_register(void);
> +void __exit msm_dsi_unregister(void);
> +#else
> +static inline void __init msm_dsi_register(void)
> +{
> +}
> +static inline void __exit msm_dsi_unregister(void)
> +{
> +}
> +#endif
> +
>   #ifdef CONFIG_DEBUG_FS
>   void msm_gem_describe(struct drm_gem_object *obj, struct seq_file *m);
>   void msm_gem_describe_objects(struct list_head *list, struct seq_file *m);
>

Thanks for the patch.

Archit

-- 
Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum,
a Linux Foundation Collaborative Project