drm/msm/dp: add support for dp drm

/*

 * Copyright (c) 2017, 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.

 *

 */

#define pr_fmt(fmt)	"[drm-dp]: %s: " fmt, __func__

#include <drm/drm_atomic_helper.h>

#include <drm/drm_atomic.h>

#include <drm/drm_crtc.h>

#include "msm_drv.h"

#include "msm_kms.h"

#include "sde_connector.h"

#include "dp_drm.h"

#define to_dp_bridge(x)     container_of((x), struct dp_bridge, base)

static void convert_to_dp_mode(const struct drm_display_mode *drm_mode,

				struct dp_display_mode *dp_mode)

{

	memset(dp_mode, 0, sizeof(*dp_mode));

	dp_mode->timing.h_active = drm_mode->hdisplay;

	dp_mode->timing.h_back_porch = drm_mode->htotal - drm_mode->hsync_end;

	dp_mode->timing.h_sync_width = drm_mode->htotal -

			(drm_mode->hsync_start + dp_mode->timing.h_back_porch);

	dp_mode->timing.h_front_porch = drm_mode->hsync_start -

					 drm_mode->hdisplay;

	dp_mode->timing.h_skew = drm_mode->hskew;

	dp_mode->timing.v_active = drm_mode->vdisplay;

	dp_mode->timing.v_back_porch = drm_mode->vtotal - drm_mode->vsync_end;

	dp_mode->timing.v_sync_width = drm_mode->vtotal -

		(drm_mode->vsync_start + dp_mode->timing.v_back_porch);

	dp_mode->timing.v_front_porch = drm_mode->vsync_start -

					 drm_mode->vdisplay;

	dp_mode->timing.refresh_rate = drm_mode->vrefresh;

	dp_mode->timing.pixel_clk_khz = drm_mode->clock;

	dp_mode->timing.v_active_low =

		!!(drm_mode->flags & DRM_MODE_FLAG_NVSYNC);

	dp_mode->timing.h_active_low =

		!!(drm_mode->flags & DRM_MODE_FLAG_NHSYNC);

}

static void convert_to_drm_mode(const struct dp_display_mode *dp_mode,

				struct drm_display_mode *drm_mode)

{

	u32 flags = 0;

	memset(drm_mode, 0, sizeof(*drm_mode));

	drm_mode->hdisplay = dp_mode->timing.h_active;

	drm_mode->hsync_start = drm_mode->hdisplay +

				dp_mode->timing.h_front_porch;

	drm_mode->hsync_end = drm_mode->hsync_start +

			      dp_mode->timing.h_sync_width;

	drm_mode->htotal = drm_mode->hsync_end + dp_mode->timing.h_back_porch;

	drm_mode->hskew = dp_mode->timing.h_skew;

	drm_mode->vdisplay = dp_mode->timing.v_active;

	drm_mode->vsync_start = drm_mode->vdisplay +

				dp_mode->timing.v_front_porch;

	drm_mode->vsync_end = drm_mode->vsync_start +

			      dp_mode->timing.v_sync_width;

	drm_mode->vtotal = drm_mode->vsync_end + dp_mode->timing.v_back_porch;

	drm_mode->vrefresh = dp_mode->timing.refresh_rate;

	drm_mode->clock = dp_mode->timing.pixel_clk_khz;

	if (dp_mode->timing.h_active_low)

		flags |= DRM_MODE_FLAG_NHSYNC;

	else

		flags |= DRM_MODE_FLAG_PHSYNC;

	if (dp_mode->timing.v_active_low)

		flags |= DRM_MODE_FLAG_NVSYNC;

	else

		flags |= DRM_MODE_FLAG_PVSYNC;

	drm_mode->flags = flags;

	drm_mode->type = 0x48;

	drm_mode_set_name(drm_mode);

}

static int dp_bridge_attach(struct drm_bridge *dp_bridge)

{

	struct dp_bridge *bridge = to_dp_bridge(dp_bridge);

	if (!dp_bridge) {

		pr_err("Invalid params\n");

		return -EINVAL;

	}

	pr_debug("[%d] attached\n", bridge->id);

	return 0;

}

static void dp_bridge_pre_enable(struct drm_bridge *drm_bridge)

{

	int rc = 0;

	struct dp_bridge *bridge;

	struct dp_display *dp;

	if (!drm_bridge) {

		pr_err("Invalid params\n");

		return;

	}

	bridge = to_dp_bridge(drm_bridge);

	dp = bridge->display;

	/* By this point mode should have been validated through mode_fixup */

	rc = dp->set_mode(dp, &bridge->dp_mode);

	if (rc) {

		pr_err("[%d] failed to perform a mode set, rc=%d\n",

		       bridge->id, rc);

		return;

	}

	rc = dp->prepare(dp);

	if (rc) {

		pr_err("[%d] DP display prepare failed, rc=%d\n",

		       bridge->id, rc);

		return;

	}

	rc = dp->enable(dp);

	if (rc) {

		pr_err("[%d] DP display enable failed, rc=%d\n",

		       bridge->id, rc);

		dp->unprepare(dp);

	}

}

static void dp_bridge_enable(struct drm_bridge *drm_bridge)

{

	int rc = 0;

	struct dp_bridge *bridge;

	struct dp_display *dp;

	if (!drm_bridge) {

		pr_err("Invalid params\n");

		return;

	}

	bridge = to_dp_bridge(drm_bridge);

	dp = bridge->display;

	rc = dp->post_enable(dp);

	if (rc)

		pr_err("[%d] DP display post enable failed, rc=%d\n",

		       bridge->id, rc);

}

static void dp_bridge_disable(struct drm_bridge *drm_bridge)

{

	int rc = 0;

	struct dp_bridge *bridge;

	struct dp_display *dp;

	if (!drm_bridge) {

		pr_err("Invalid params\n");

		return;

	}

	bridge = to_dp_bridge(drm_bridge);

	dp = bridge->display;

	rc = dp->pre_disable(dp);

	if (rc) {

		pr_err("[%d] DP display pre disable failed, rc=%d\n",

		       bridge->id, rc);

	}

}

static void dp_bridge_post_disable(struct drm_bridge *drm_bridge)

{

	int rc = 0;

	struct dp_bridge *bridge;

	struct dp_display *dp;

	if (!drm_bridge) {

		pr_err("Invalid params\n");

		return;

	}

	bridge = to_dp_bridge(drm_bridge);

	dp = bridge->display;

	rc = dp->disable(dp);

	if (rc) {

		pr_err("[%d] DP display disable failed, rc=%d\n",

		       bridge->id, rc);

		return;

	}

	rc = dp->unprepare(dp);

	if (rc) {

		pr_err("[%d] DP display unprepare failed, rc=%d\n",

		       bridge->id, rc);

		return;

	}

}

static void dp_bridge_mode_set(struct drm_bridge *drm_bridge,

				struct drm_display_mode *mode,

				struct drm_display_mode *adjusted_mode)

{

	struct dp_bridge *bridge;

	struct dp_display *dp;

	if (!drm_bridge || !mode || !adjusted_mode) {

		pr_err("Invalid params\n");

		return;

	}

	bridge = to_dp_bridge(drm_bridge);

	dp = bridge->display;

	memset(&bridge->dp_mode, 0x0, sizeof(struct dp_display_mode));

	convert_to_dp_mode(adjusted_mode, &bridge->dp_mode);

}

static bool dp_bridge_mode_fixup(struct drm_bridge *drm_bridge,

				  const struct drm_display_mode *mode,

				  struct drm_display_mode *adjusted_mode)

{

	int rc = 0;

	bool ret = true;

	struct dp_display_mode dp_mode;

	struct dp_bridge *bridge;

	struct dp_display *dp;

	if (!drm_bridge || !mode || !adjusted_mode) {

		pr_err("Invalid params\n");

		ret = false;

		goto end;

	}

	bridge = to_dp_bridge(drm_bridge);

	dp = bridge->display;

	convert_to_dp_mode(mode, &dp_mode);

	rc = dp->validate_mode(dp, &dp_mode);

	if (rc) {

		pr_err("[%d] mode is not valid, rc=%d\n", bridge->id, rc);

		ret = false;

	} else {

		convert_to_drm_mode(&dp_mode, adjusted_mode);

	}

end:

	return ret;

}

static const struct drm_bridge_funcs dp_bridge_ops = {

	.attach       = dp_bridge_attach,

	.mode_fixup   = dp_bridge_mode_fixup,

	.pre_enable   = dp_bridge_pre_enable,

	.enable       = dp_bridge_enable,

	.disable      = dp_bridge_disable,

	.post_disable = dp_bridge_post_disable,

	.mode_set     = dp_bridge_mode_set,

};

int dp_connector_post_init(struct drm_connector *connector,

		void *info,

		void *display)

{

	struct dp_display *dp_display = display;

	if (!info || !dp_display)

		return -EINVAL;

	return 0;

}

int dp_connector_get_info(struct msm_display_info *info, void *data)

{

	struct dsi_display *display = data;

	if (!info || !display) {

		pr_err("invalid params\n");

		return -EINVAL;

	}

	info->intf_type = DRM_MODE_CONNECTOR_DisplayPort;

	info->num_of_h_tiles = 1;

	info->h_tile_instance[0] = 0;

	info->is_connected = true;

	info->frame_rate = 60;

	info->width_mm = 160;

	info->height_mm = 90;

	info->max_width = 1920;

	info->max_height = 1080;

	info->vtotal = 1125;

	info->is_primary = true;

	info->comp_info.comp_type = MSM_DISPLAY_COMPRESSION_NONE;

	info->capabilities |= MSM_DISPLAY_CAP_VID_MODE;

	return 0;

}

enum drm_connector_status dp_connector_detect(struct drm_connector *conn,

		bool force,

		void *display)

{

	enum drm_connector_status status = connector_status_unknown;

	struct msm_display_info info;

	int rc;

	if (!conn || !display)

		return status;

	/* get display dp_info */

	memset(&info, 0x0, sizeof(info));

	rc = dp_connector_get_info(&info, display);

	if (rc) {

		pr_err("failed to get display info, rc=%d\n", rc);

		return connector_status_disconnected;

	}

	if (info.capabilities & MSM_DISPLAY_CAP_HOT_PLUG)

		status = (info.is_connected ? connector_status_connected :

					      connector_status_disconnected);

	else

		status = connector_status_connected;

	conn->display_info.width_mm = info.width_mm;

	conn->display_info.height_mm = info.height_mm;

	return status;

}

int dp_connector_get_modes(struct drm_connector *connector,

		void *display)

{

	u32 count = 0;

	u32 size = 0;

	struct dp_display_mode *modes;

	struct drm_display_mode drm_mode;

	struct dp_display *dp;

	int rc, i;

	if (!connector || !display || sde_connector_get_panel(connector))

		goto end;

	dp = display;

	rc = dp->get_modes(dp, NULL, &count);

	if (rc) {

		pr_err("failed to get num of modes, rc=%d\n", rc);

		goto end;

	}

	size = count * sizeof(*modes);

	modes = kzalloc(size,  GFP_KERNEL);

	if (!modes) {

		count = 0;

		goto end;

	}

	rc = dp->get_modes(dp, modes, &count);

	if (rc) {

		pr_err("failed to get modes, rc=%d\n", rc);

		count = 0;

		goto error;

	}

	for (i = 0; i < count; i++) {

		struct drm_display_mode *m;

		memset(&drm_mode, 0x0, sizeof(drm_mode));

		convert_to_drm_mode(&modes[i], &drm_mode);

		m = drm_mode_duplicate(connector->dev, &drm_mode);

		if (!m) {

			pr_err("failed to add mode %ux%u\n",

			       drm_mode.hdisplay,

			       drm_mode.vdisplay);

			count = -ENOMEM;

			goto error;

		}

		m->width_mm = connector->display_info.width_mm;

		m->height_mm = connector->display_info.height_mm;

		drm_mode_probed_add(connector, m);

	}

error:

	kfree(modes);

end:

	pr_debug("MODE COUNT =%d\n\n", count);

	return count;

}

int dp_drm_bridge_init(void *data, struct drm_encoder *encoder)

{

	int rc = 0;

	struct dp_bridge *bridge;

	struct drm_device *dev;

	struct dp_display *display = data;

	struct msm_drm_private *priv = NULL;

	bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);

	if (!bridge) {

		rc = -ENOMEM;

		goto error;

	}

	dev = display->drm_dev;

	bridge->display = display;

	bridge->base.funcs = &dp_bridge_ops;

	bridge->base.encoder = encoder;

	priv = dev->dev_private;

	rc = drm_bridge_attach(dev, &bridge->base);

	if (rc) {

		pr_err("failed to attach bridge, rc=%d\n", rc);

		goto error_free_bridge;

	}

	encoder->bridge = &bridge->base;

	priv->bridges[priv->num_bridges++] = &bridge->base;

	display->bridge = bridge;

	return 0;

error_free_bridge:

	kfree(bridge);

error:

	return rc;

}

void dp_drm_bridge_deinit(void *data)

{

	struct dp_display *display = data;

	struct dp_bridge *bridge = display->bridge;

	if (bridge && bridge->base.encoder)

		bridge->base.encoder->bridge = NULL;

	kfree(bridge);

}

enum drm_mode_status dp_connector_mode_valid(struct drm_connector *connector,

		struct drm_display_mode *mode,

		void *display)

{

	return MODE_OK;

}

/*

 * Copyright (c) 2017, 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 _DP_DRM_H_

#define _DP_DRM_H_

#include <linux/types.h>

#include <drm/drmP.h>

#include <drm/drm_crtc.h>

#include <drm/drm_crtc_helper.h>

#include "msm_drv.h"

#include "dp_display.h"

struct dp_bridge {

	struct drm_bridge base;

	u32 id;

	struct dp_display *display;

	struct dp_display_mode dp_mode;

};

/**

 * dp_connector_post_init - callback to perform additional initialization steps

 * @connector: Pointer to drm connector structure

 * @info: Pointer to sde connector info structure

 * @display: Pointer to private display handle

 * Returns: Zero on success

 */

int dp_connector_post_init(struct drm_connector *connector,

		void *info,

		void *display);

/**

 * dp_connector_detect - callback to determine if connector is connected

 * @connector: Pointer to drm connector structure

 * @force: Force detect setting from drm framework

 * @display: Pointer to private display handle

 * Returns: Connector 'is connected' status

 */

enum drm_connector_status dp_connector_detect(struct drm_connector *conn,

		bool force,

		void *display);

/**

 * dp_connector_get_modes - callback to add drm modes via drm_mode_probed_add()

 * @connector: Pointer to drm connector structure

 * @display: Pointer to private display handle

 * Returns: Number of modes added

 */

int dp_connector_get_modes(struct drm_connector *connector,

		void *display);

/**

 * dp_connector_mode_valid - callback to determine if specified mode is valid

 * @connector: Pointer to drm connector structure

 * @mode: Pointer to drm mode structure

 * @display: Pointer to private display handle

 * Returns: Validity status for specified mode

 */

enum drm_mode_status dp_connector_mode_valid(struct drm_connector *connector,

		struct drm_display_mode *mode,

		void *display);

int dp_connector_get_info(struct msm_display_info *info, void *display);

int dp_drm_bridge_init(void *display,

	struct drm_encoder *encoder);

void dp_drm_bridge_deinit(void *display);

#endif /* _DP_DRM_H_ */

 * Returns: Pointer to associated private display structure

 */

#define sde_connector_get_panel(C) \

	((C) ? to_sde_connector((C))->panel : 0)

	((C) ? to_sde_connector((C))->panel : NULL)

/**

 * sde_connector_get_encoder - get sde connector's private encoder pointer