Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 1e024620 authored by Satya Rama Aditya Pinapala's avatar Satya Rama Aditya Pinapala
Browse files

drm/msm/sde: msm and sde driver snanpshot 



This snapshot includes SDE and supporting include files.
This change also has the copyright year update in the files.
Snapshot was taken from msm-4.14 as of commit 1df57774
("Merge "ARM: dts: msm: Remove dma-coherent for IPA for sdxprairie"").

Change-Id: I328399cce8cd1eb031c53730003ec970a2d687be
Signed-off-by: default avatarSatya Rama Aditya Pinapala <psraditya30@codeaurora.org>
parent 30b63727

drivers/gpu/drm/msm/msm_drv.c

+22 −53
Original line number Diff line number Diff line
@@ -298,62 +298,46 @@ u32 msm_readl(const void __iomem *addr) 
	return val;

}



struct vblank_event {

	struct list_head node;

struct vblank_work {

	struct kthread_work work;

	int crtc_id;

	bool enable;

	struct msm_drm_private *priv;

};



static void vblank_ctrl_worker(struct kthread_work *work)

{

	struct msm_vblank_ctrl *vbl_ctrl = container_of(work,

						struct msm_vblank_ctrl, work);

	struct msm_drm_private *priv = container_of(vbl_ctrl,

					struct msm_drm_private, vblank_ctrl);

	struct vblank_work *cur_work = container_of(work,

					struct vblank_work, work);

	struct msm_drm_private *priv = cur_work->priv;

	struct msm_kms *kms = priv->kms;

	struct vblank_event *vbl_ev, *tmp;

	unsigned long flags;

	LIST_HEAD(tmp_head);



	spin_lock_irqsave(&vbl_ctrl->lock, flags);

	list_for_each_entry_safe(vbl_ev, tmp, &vbl_ctrl->event_list, node) {

		list_del(&vbl_ev->node);

		list_add_tail(&vbl_ev->node, &tmp_head);

	}

	spin_unlock_irqrestore(&vbl_ctrl->lock, flags);



	list_for_each_entry_safe(vbl_ev, tmp, &tmp_head, node) {

		if (vbl_ev->enable)

			kms->funcs->enable_vblank(kms,

						priv->crtcs[vbl_ev->crtc_id]);

	if (cur_work->enable)

		kms->funcs->enable_vblank(kms, priv->crtcs[cur_work->crtc_id]);

	else

			kms->funcs->disable_vblank(kms,

						priv->crtcs[vbl_ev->crtc_id]);

		kms->funcs->disable_vblank(kms, priv->crtcs[cur_work->crtc_id]);



		kfree(vbl_ev);

	}

	kfree(cur_work);

}



static int vblank_ctrl_queue_work(struct msm_drm_private *priv,

					int crtc_id, bool enable)

{

	struct msm_vblank_ctrl *vbl_ctrl = &priv->vblank_ctrl;

	struct vblank_event *vbl_ev;

	unsigned long flags;

	struct vblank_work *cur_work;



	vbl_ev = kzalloc(sizeof(*vbl_ev), GFP_ATOMIC);

	if (!vbl_ev)

		return -ENOMEM;

	if (!priv || crtc_id >= priv->num_crtcs)

		return -EINVAL;



	vbl_ev->crtc_id = crtc_id;

	vbl_ev->enable = enable;

	cur_work = kzalloc(sizeof(*cur_work), GFP_ATOMIC);

	if (!cur_work)

		return -ENOMEM;



	spin_lock_irqsave(&vbl_ctrl->lock, flags);

	list_add_tail(&vbl_ev->node, &vbl_ctrl->event_list);

	spin_unlock_irqrestore(&vbl_ctrl->lock, flags);

	kthread_init_work(&cur_work->work, vblank_ctrl_worker);

	cur_work->crtc_id = crtc_id;

	cur_work->enable = enable;

	cur_work->priv = priv;



	kthread_queue_work(&priv->disp_thread[crtc_id].worker,

			&vbl_ctrl->work);

	kthread_queue_work(&priv->disp_thread[crtc_id].worker, &cur_work->work);



	return 0;

}
@@ -365,20 +349,8 @@ static int msm_drm_uninit(struct device *dev) 
	struct msm_drm_private *priv = ddev->dev_private;

	struct msm_kms *kms = priv->kms;

	struct msm_gpu *gpu = priv->gpu;

	struct msm_vblank_ctrl *vbl_ctrl = &priv->vblank_ctrl;

	struct vblank_event *vbl_ev, *tmp;

	int i;



	/* We must cancel and cleanup any pending vblank enable/disable

	 * work before drm_irq_uninstall() to avoid work re-enabling an

	 * irq after uninstall has disabled it.

	 */

	kthread_flush_work(&vbl_ctrl->work);

	list_for_each_entry_safe(vbl_ev, tmp, &vbl_ctrl->event_list, node) {

		list_del(&vbl_ev->node);

		kfree(vbl_ev);

	}



	/* clean up display commit/event worker threads */

	for (i = 0; i < priv->num_crtcs; i++) {

		if (priv->disp_thread[i].thread) {
@@ -778,9 +750,6 @@ static int msm_drm_init(struct device *dev, struct drm_driver *drv) 


	INIT_LIST_HEAD(&priv->client_event_list);

	INIT_LIST_HEAD(&priv->inactive_list);

	INIT_LIST_HEAD(&priv->vblank_ctrl.event_list);

	kthread_init_work(&priv->vblank_ctrl.work, vblank_ctrl_worker);

	spin_lock_init(&priv->vblank_ctrl.lock);



	ret = sde_power_resource_init(pdev, &priv->phandle);

	if (ret) {

drivers/gpu/drm/msm/msm_drv.h

+0 −7
Original line number Diff line number Diff line
@@ -198,12 +198,6 @@ enum msm_mdp_conn_property { 
	CONNECTOR_PROP_COUNT

};



struct msm_vblank_ctrl {

	struct kthread_work work;

	struct list_head event_list;

	spinlock_t lock;

};



#define MSM_GPU_MAX_RINGS 4

#define MAX_H_TILES_PER_DISPLAY 2
@@ -644,7 +638,6 @@ struct msm_drm_private { 
	struct notifier_block vmap_notifier;

	struct shrinker shrinker;



	struct msm_vblank_ctrl vblank_ctrl;

	struct drm_atomic_state *pm_state;



	/* task holding struct_mutex.. currently only used in submit path

drivers/gpu/drm/msm/msm_gem.c

+1 −1
Original line number Diff line number Diff line
@@ -341,7 +341,7 @@ dma_addr_t msm_gem_get_dma_addr(struct drm_gem_object *obj) 
		sgt = dma_buf_map_attachment(obj->import_attach,

						DMA_BIDIRECTIONAL);

		if (IS_ERR_OR_NULL(sgt)) {

			DRM_ERROR("dma_buf_map_attachment failure, err=%d\n",

			DRM_ERROR("dma_buf_map_attachment failure, err=%ld\n",

					PTR_ERR(sgt));

			return 0;

		}

drivers/gpu/drm/msm/sde/sde_connector.c

+78 −34
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-only

/*

 * Copyright (c) 2016-2018, The Linux Foundation. All rights reserved.

 * Copyright (c) 2016-2019, The Linux Foundation. All rights reserved.

 */



#define pr_fmt(fmt)	"[drm:%s:%d] " fmt, __func__, __LINE__
@@ -92,6 +92,12 @@ static int sde_backlight_device_update_status(struct backlight_device *bd) 
	if (!bl_lvl && brightness)

		bl_lvl = 1;



	if (display->panel->bl_config.bl_update ==

		BL_UPDATE_DELAY_UNTIL_FIRST_FRAME && !c_conn->allow_bl_update) {

		c_conn->unset_bl_level = bl_lvl;

		return 0;

	}



	if (c_conn->ops.set_backlight) {

		event.type = DRM_EVENT_SYS_BACKLIGHT;

		event.length = sizeof(u32);
@@ -99,6 +105,7 @@ static int sde_backlight_device_update_status(struct backlight_device *bd) 
				c_conn->base.dev, &event, (u8 *)&brightness);

		rc = c_conn->ops.set_backlight(&c_conn->base,

				c_conn->display, bl_lvl);

		c_conn->unset_bl_level = 0;

	}



	return rc;
@@ -543,6 +550,26 @@ static int _sde_connector_update_bl_scale(struct sde_connector *c_conn) 
	return rc;

}



void sde_connector_set_qsync_params(struct drm_connector *connector)

{

	struct sde_connector *c_conn = to_sde_connector(connector);

	u32 qsync_propval;



	if (!connector)

		return;



	c_conn->qsync_updated = false;

	qsync_propval = sde_connector_get_property(c_conn->base.state,

			CONNECTOR_PROP_QSYNC_MODE);



	if (qsync_propval != c_conn->qsync_mode) {

		SDE_DEBUG("updated qsync mode %d -> %d\n", c_conn->qsync_mode,

				qsync_propval);

		c_conn->qsync_updated = true;

		c_conn->qsync_mode = qsync_propval;

	}

}



static int _sde_connector_update_dirty_properties(

				struct drm_connector *connector)

{
@@ -557,7 +584,6 @@ static int _sde_connector_update_dirty_properties( 


	c_conn = to_sde_connector(connector);

	c_state = to_sde_connector_state(connector->state);

	c_conn->qsync_updated = false;



	while ((idx = msm_property_pop_dirty(&c_conn->property_info,

					&c_state->property_state)) >= 0) {
@@ -573,19 +599,17 @@ static int _sde_connector_update_dirty_properties( 
		case CONNECTOR_PROP_AD_BL_SCALE:

			_sde_connector_update_bl_scale(c_conn);

			break;

		case CONNECTOR_PROP_QSYNC_MODE:

			c_conn->qsync_updated = true;

			c_conn->qsync_mode = sde_connector_get_property(

				connector->state, CONNECTOR_PROP_QSYNC_MODE);

			break;

		default:

			/* nothing to do for most properties */

			break;

		}

	}



	/* Special handling for postproc properties */

	if (c_conn->bl_scale_dirty) {

	/*

	 * Special handling for postproc properties and

	 * for updating backlight if any unset backlight level is present

	 */

	if (c_conn->bl_scale_dirty || c_conn->unset_bl_level) {

		_sde_connector_update_bl_scale(c_conn);

		c_conn->bl_scale_dirty = false;

	}
@@ -658,29 +682,44 @@ void sde_connector_helper_bridge_disable(struct drm_connector *connector) 
	sde_connector_schedule_status_work(connector, false);



	c_conn = to_sde_connector(connector);

	if (c_conn->panel_dead) {

	if (c_conn->bl_device) {

		c_conn->bl_device->props.power = FB_BLANK_POWERDOWN;

		c_conn->bl_device->props.state |= BL_CORE_FBBLANK;

		backlight_update_status(c_conn->bl_device);

	}



	c_conn->allow_bl_update = false;

}



void sde_connector_helper_bridge_enable(struct drm_connector *connector)

{

	struct sde_connector *c_conn = NULL;

	struct dsi_display *display;



	if (!connector)

		return;



	c_conn = to_sde_connector(connector);

	display = (struct dsi_display *) c_conn->display;



	/*

	 * Special handling for some panels which need atleast

	 * one frame to be transferred to GRAM before enabling backlight.

	 * So delay backlight update to these panels until the

	 * first frame commit is received from the HW.

	 */

	if (display->panel->bl_config.bl_update ==

				BL_UPDATE_DELAY_UNTIL_FIRST_FRAME)

		sde_encoder_wait_for_event(c_conn->encoder,

				MSM_ENC_TX_COMPLETE);

	c_conn->allow_bl_update = true;



	/* Special handling for ESD recovery case */

	if (c_conn->panel_dead) {

	if (c_conn->bl_device) {

		c_conn->bl_device->props.power = FB_BLANK_UNBLANK;

		c_conn->bl_device->props.state &= ~BL_CORE_FBBLANK;

		backlight_update_status(c_conn->bl_device);

		c_conn->panel_dead = false;

	}

	c_conn->panel_dead = false;

}



int sde_connector_clk_ctrl(struct drm_connector *connector, bool enable)
@@ -1273,24 +1312,17 @@ void sde_connector_commit_reset(struct drm_connector *connector, ktime_t ts) 
static void sde_connector_update_hdr_props(struct drm_connector *connector)

{

	struct sde_connector *c_conn = to_sde_connector(connector);

	struct drm_msm_ext_hdr_properties hdr = {};



	hdr.hdr_supported = connector->hdr_supported;



	if (hdr.hdr_supported) {

		hdr.hdr_eotf = connector->hdr_eotf;

		hdr.hdr_metadata_type_one = connector->hdr_metadata_type_one;

		hdr.hdr_max_luminance = connector->hdr_max_luminance;

		hdr.hdr_avg_luminance = connector->hdr_avg_luminance;

		hdr.hdr_min_luminance = connector->hdr_min_luminance;



		msm_property_set_blob(&c_conn->property_info,

			      &c_conn->blob_ext_hdr,

			      &hdr,

			      sizeof(hdr),

			      CONNECTOR_PROP_EXT_HDR_INFO);

	struct drm_msm_ext_hdr_properties hdr = {

		connector->hdr_metadata_type_one,

		connector->hdr_supported,

		connector->hdr_eotf,

		connector->hdr_max_luminance,

		connector->hdr_avg_luminance,

		connector->hdr_min_luminance,

	};



	}

	msm_property_set_blob(&c_conn->property_info, &c_conn->blob_ext_hdr,

			&hdr, sizeof(hdr), CONNECTOR_PROP_EXT_HDR_INFO);

}



static enum drm_connector_status
@@ -1690,6 +1722,7 @@ static int sde_connector_get_modes(struct drm_connector *connector) 
		return 0;

	}



	if (c_conn->hdr_capable)

		sde_connector_update_hdr_props(connector);



	return mode_count;
@@ -1802,6 +1835,7 @@ static void _sde_connector_report_panel_dead(struct sde_connector *conn) 
int sde_connector_esd_status(struct drm_connector *conn)

{

	struct sde_connector *sde_conn = NULL;

	struct dsi_display *display;

	int ret = 0;



	if (!conn)
@@ -1811,10 +1845,17 @@ int sde_connector_esd_status(struct drm_connector *conn) 
	if (!sde_conn || !sde_conn->ops.check_status)

		return ret;



	display = sde_conn->display;



	/* protect this call with ESD status check call */

	mutex_lock(&sde_conn->lock);

	ret = sde_conn->ops.check_status(&sde_conn->base, sde_conn->display,

								true);

	if (atomic_read(&(display->panel->esd_recovery_pending))) {

		SDE_ERROR("ESD recovery already pending\n");

		mutex_unlock(&sde_conn->lock);

		return -ETIMEDOUT;

	}

	ret = sde_conn->ops.check_status(&sde_conn->base,

					 sde_conn->display, true);

	mutex_unlock(&sde_conn->lock);



	if (ret <= 0) {
@@ -1936,6 +1977,9 @@ static int sde_connector_populate_mode_info(struct drm_connector *conn, 
			continue;

		}



		sde_kms_info_add_keyint(info, "mdp_transfer_time_us",

			mode_info.mdp_transfer_time_us);



		if (!mode_info.roi_caps.num_roi)

			continue;

drivers/gpu/drm/msm/sde/sde_connector.h

+28 −3
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0-only */

/*

 * Copyright (c) 2016-2018, The Linux Foundation. All rights reserved.

 * Copyright (c) 2016-2019, The Linux Foundation. All rights reserved.

 */



#ifndef _SDE_CONNECTOR_H_
@@ -366,9 +366,12 @@ struct sde_connector_evt { 
 * @bl_scale_dirty: Flag to indicate PP BL scale value(s) is changed

 * @bl_scale: BL scale value for ABA feature

 * @bl_scale_ad: BL scale value for AD feature

 * @qsync_mode: Qsync mode, where 0: disabled 1: continuous mode

 * @unset_bl_level: BL level that needs to be set later

 * @allow_bl_update: Flag to indicate if BL update is allowed currently or not

 * @qsync_mode: Cached Qsync mode, 0=disabled, 1=continuous mode

 * @qsync_updated: Qsync settings were updated

 * last_cmd_tx_sts: status of the last command transfer

 * @hdr_capable: external hdr support present

 */

struct sde_connector {

	struct drm_connector base;
@@ -413,11 +416,14 @@ struct sde_connector { 
	bool bl_scale_dirty;

	u32 bl_scale;

	u32 bl_scale_ad;

	u32 unset_bl_level;

	bool allow_bl_update;



	u32 qsync_mode;

	bool qsync_updated;



	bool last_cmd_tx_sts;

	bool hdr_capable;

};



/**
@@ -456,9 +462,17 @@ struct sde_connector { 
 * @C: Pointer to drm connector structure

 * Returns: True if qsync is updated; false otherwise

 */

#define sde_connector_qsync_updated(C) \

#define sde_connector_is_qsync_updated(C) \

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



/**

 * sde_connector_get_qsync_mode - get sde connector's qsync_mode

 * @C: Pointer to drm connector structure

 * Returns: Current cached qsync_mode for given connector

 */

#define sde_connector_get_qsync_mode(C) \

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



/**

 * sde_connector_get_propinfo - get sde connector's property info pointer

 * @C: Pointer to drm connector structure
@@ -672,6 +686,17 @@ int sde_connector_clk_ctrl(struct drm_connector *connector, bool enable); 
 */

int sde_connector_get_dpms(struct drm_connector *connector);



/**

 * sde_connector_set_qsync_params - set status of qsync_updated for current

 *                                  frame and update the cached qsync_mode

 * @connector: pointer to drm connector

 *

 * This must be called after the connector set_property values are applied,

 * and before sde_connector's qsync_updated or qsync_mode fields are accessed.

 * It must only be called once per frame update for the given connector.

 */

void sde_connector_set_qsync_params(struct drm_connector *connector);



/**

 * sde_connector_trigger_event - indicate that an event has occurred

 *	Any callbacks that have been registered against this event will