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

Commit e172d10a authored by Beeresh Gopal's avatar Beeresh Gopal Committed by Rob Clark
Browse files

drm/msm/mdp5: Add hardware cursor support 



This patch implements the hardware accelarated cursor
support for MDP5 platforms.

Signed-off-by: default avatarBeeresh Gopal <gbeeresh@codeaurora.org>
Signed-off-by: default avatarWentao Xu <wentaox@codeaurora.org>
Signed-off-by: default avatarStephane Viau <sviau@codeaurora.org>
Signed-off-by: default avatarRob Clark <robdclark@gmail.com>
parent 5eba5d87

drivers/gpu/drm/msm/mdp/mdp5/mdp5_crtc.c

+164 −0
Original line number Original line Diff line number Diff line
@@ -24,6 +24,9 @@ 
#include "drm_crtc_helper.h"

#include "drm_crtc_helper.h"

#include "drm_flip_work.h"

#include "drm_flip_work.h"





#define CURSOR_WIDTH	64

#define CURSOR_HEIGHT	64



#define SSPP_MAX	(SSPP_RGB3 + 1) /* TODO: Add SSPP_MAX in mdp5.xml.h */

#define SSPP_MAX	(SSPP_RGB3 + 1) /* TODO: Add SSPP_MAX in mdp5.xml.h */





struct mdp5_crtc {

struct mdp5_crtc {
@@ -47,8 +50,21 @@ struct mdp5_crtc { 
#define PENDING_FLIP   0x2

#define PENDING_FLIP   0x2

	atomic_t pending;

	atomic_t pending;





	/* for unref'ing cursor bo's after scanout completes: */

	struct drm_flip_work unref_cursor_work;



	struct mdp_irq vblank;

	struct mdp_irq vblank;

	struct mdp_irq err;

	struct mdp_irq err;



	struct {

		/* protect REG_MDP5_LM_CURSOR* registers and cursor scanout_bo*/

		spinlock_t lock;



		/* current cursor being scanned out: */

		struct drm_gem_object *scanout_bo;

		uint32_t width;

		uint32_t height;

	} cursor;

};

};

#define to_mdp5_crtc(x) container_of(x, struct mdp5_crtc, base)

#define to_mdp5_crtc(x) container_of(x, struct mdp5_crtc, base)
@@ -129,11 +145,22 @@ static void complete_flip(struct drm_crtc *crtc, struct drm_file *file) 
	}

	}

}

}





static void unref_cursor_worker(struct drm_flip_work *work, void *val)

{

	struct mdp5_crtc *mdp5_crtc =

		container_of(work, struct mdp5_crtc, unref_cursor_work);

	struct mdp5_kms *mdp5_kms = get_kms(&mdp5_crtc->base);



	msm_gem_put_iova(val, mdp5_kms->id);

	drm_gem_object_unreference_unlocked(val);

}



static void mdp5_crtc_destroy(struct drm_crtc *crtc)

static void mdp5_crtc_destroy(struct drm_crtc *crtc)

{

{

	struct mdp5_crtc *mdp5_crtc = to_mdp5_crtc(crtc);

	struct mdp5_crtc *mdp5_crtc = to_mdp5_crtc(crtc);





	drm_crtc_cleanup(crtc);

	drm_crtc_cleanup(crtc);

	drm_flip_work_cleanup(&mdp5_crtc->unref_cursor_work);





	kfree(mdp5_crtc);

	kfree(mdp5_crtc);

}

}
@@ -376,6 +403,132 @@ static int mdp5_crtc_set_property(struct drm_crtc *crtc, 
	return -EINVAL;

	return -EINVAL;

}

}





static int mdp5_crtc_cursor_set(struct drm_crtc *crtc,

		struct drm_file *file, uint32_t handle,

		uint32_t width, uint32_t height)

{

	struct mdp5_crtc *mdp5_crtc = to_mdp5_crtc(crtc);

	struct drm_device *dev = crtc->dev;

	struct mdp5_kms *mdp5_kms = get_kms(crtc);

	struct drm_gem_object *cursor_bo, *old_bo;

	uint32_t blendcfg, cursor_addr, stride;

	int ret, bpp, lm;

	unsigned int depth;

	enum mdp5_cursor_alpha cur_alpha = CURSOR_ALPHA_PER_PIXEL;

	uint32_t flush_mask = mdp_ctl_flush_mask_cursor(0);

	unsigned long flags;



	if ((width > CURSOR_WIDTH) || (height > CURSOR_HEIGHT)) {

		dev_err(dev->dev, "bad cursor size: %dx%d\n", width, height);

		return -EINVAL;

	}



	if (NULL == mdp5_crtc->ctl)

		return -EINVAL;



	if (!handle) {

		DBG("Cursor off");

		return mdp5_ctl_set_cursor(mdp5_crtc->ctl, false);

	}



	cursor_bo = drm_gem_object_lookup(dev, file, handle);

	if (!cursor_bo)

		return -ENOENT;



	ret = msm_gem_get_iova(cursor_bo, mdp5_kms->id, &cursor_addr);

	if (ret)

		return -EINVAL;



	lm = mdp5_crtc->lm;

	drm_fb_get_bpp_depth(DRM_FORMAT_ARGB8888, &depth, &bpp);

	stride = width * (bpp >> 3);



	spin_lock_irqsave(&mdp5_crtc->cursor.lock, flags);

	old_bo = mdp5_crtc->cursor.scanout_bo;



	mdp5_write(mdp5_kms, REG_MDP5_LM_CURSOR_STRIDE(lm), stride);

	mdp5_write(mdp5_kms, REG_MDP5_LM_CURSOR_FORMAT(lm),

			MDP5_LM_CURSOR_FORMAT_FORMAT(CURSOR_FMT_ARGB8888));

	mdp5_write(mdp5_kms, REG_MDP5_LM_CURSOR_IMG_SIZE(lm),

			MDP5_LM_CURSOR_IMG_SIZE_SRC_H(height) |

			MDP5_LM_CURSOR_IMG_SIZE_SRC_W(width));

	mdp5_write(mdp5_kms, REG_MDP5_LM_CURSOR_SIZE(lm),

			MDP5_LM_CURSOR_SIZE_ROI_H(height) |

			MDP5_LM_CURSOR_SIZE_ROI_W(width));

	mdp5_write(mdp5_kms, REG_MDP5_LM_CURSOR_BASE_ADDR(lm), cursor_addr);





	blendcfg = MDP5_LM_CURSOR_BLEND_CONFIG_BLEND_EN;

	blendcfg |= MDP5_LM_CURSOR_BLEND_CONFIG_BLEND_TRANSP_EN;

	blendcfg |= MDP5_LM_CURSOR_BLEND_CONFIG_BLEND_ALPHA_SEL(cur_alpha);

	mdp5_write(mdp5_kms, REG_MDP5_LM_CURSOR_BLEND_CONFIG(lm), blendcfg);



	mdp5_crtc->cursor.scanout_bo = cursor_bo;

	mdp5_crtc->cursor.width = width;

	mdp5_crtc->cursor.height = height;

	spin_unlock_irqrestore(&mdp5_crtc->cursor.lock, flags);



	ret = mdp5_ctl_set_cursor(mdp5_crtc->ctl, true);

	if (ret)

		goto end;



	flush_mask |= mdp5_ctl_get_flush(mdp5_crtc->ctl);

	crtc_flush(crtc, flush_mask);



end:

	if (old_bo) {

		drm_flip_work_queue(&mdp5_crtc->unref_cursor_work, old_bo);

		/* enable vblank to complete cursor work: */

		request_pending(crtc, PENDING_CURSOR);

	}

	return ret;

}



static int mdp5_crtc_cursor_move(struct drm_crtc *crtc, int x, int y)

{

	struct mdp5_kms *mdp5_kms = get_kms(crtc);

	struct mdp5_crtc *mdp5_crtc = to_mdp5_crtc(crtc);

	uint32_t flush_mask = mdp_ctl_flush_mask_cursor(0);

	uint32_t xres = crtc->mode.hdisplay;

	uint32_t yres = crtc->mode.vdisplay;

	uint32_t roi_w;

	uint32_t roi_h;

	unsigned long flags;



	x = (x > 0) ? x : 0;

	y = (y > 0) ? y : 0;



	/*

	 * Cursor Region Of Interest (ROI) is a plane read from cursor

	 * buffer to render. The ROI region is determined by the visiblity of

	 * the cursor point. In the default Cursor image the cursor point will

	 * be at the top left of the cursor image, unless it is specified

	 * otherwise using hotspot feature.

	 *

	 * If the cursor point reaches the right (xres - x < cursor.width) or

	 * bottom (yres - y < cursor.height) boundary of the screen, then ROI

	 * width and ROI height need to be evaluated to crop the cursor image

	 * accordingly.

	 * (xres-x) will be new cursor width when x > (xres - cursor.width)

	 * (yres-y) will be new cursor height when y > (yres - cursor.height)

	 */

	roi_w = min(mdp5_crtc->cursor.width, xres - x);

	roi_h = min(mdp5_crtc->cursor.height, yres - y);



	spin_lock_irqsave(&mdp5_crtc->cursor.lock, flags);

	mdp5_write(mdp5_kms, REG_MDP5_LM_CURSOR_SIZE(mdp5_crtc->lm),

			MDP5_LM_CURSOR_SIZE_ROI_H(roi_h) |

			MDP5_LM_CURSOR_SIZE_ROI_W(roi_w));

	mdp5_write(mdp5_kms, REG_MDP5_LM_CURSOR_START_XY(mdp5_crtc->lm),

			MDP5_LM_CURSOR_START_XY_Y_START(y) |

			MDP5_LM_CURSOR_START_XY_X_START(x));

	spin_unlock_irqrestore(&mdp5_crtc->cursor.lock, flags);



	crtc_flush(crtc, flush_mask);



	return 0;

}



static const struct drm_crtc_funcs mdp5_crtc_funcs = {

static const struct drm_crtc_funcs mdp5_crtc_funcs = {

	.set_config = drm_atomic_helper_set_config,

	.set_config = drm_atomic_helper_set_config,

	.destroy = mdp5_crtc_destroy,

	.destroy = mdp5_crtc_destroy,
@@ -384,6 +537,8 @@ static const struct drm_crtc_funcs mdp5_crtc_funcs = { 
	.reset = drm_atomic_helper_crtc_reset,

	.reset = drm_atomic_helper_crtc_reset,

	.atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,

	.atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,

	.atomic_destroy_state = drm_atomic_helper_crtc_destroy_state,

	.atomic_destroy_state = drm_atomic_helper_crtc_destroy_state,

	.cursor_set = mdp5_crtc_cursor_set,

	.cursor_move = mdp5_crtc_cursor_move,

};

};





static const struct drm_crtc_helper_funcs mdp5_crtc_helper_funcs = {

static const struct drm_crtc_helper_funcs mdp5_crtc_helper_funcs = {
@@ -400,6 +555,7 @@ static void mdp5_crtc_vblank_irq(struct mdp_irq *irq, uint32_t irqstatus) 
{

{

	struct mdp5_crtc *mdp5_crtc = container_of(irq, struct mdp5_crtc, vblank);

	struct mdp5_crtc *mdp5_crtc = container_of(irq, struct mdp5_crtc, vblank);

	struct drm_crtc *crtc = &mdp5_crtc->base;

	struct drm_crtc *crtc = &mdp5_crtc->base;

	struct msm_drm_private *priv = crtc->dev->dev_private;

	unsigned pending;

	unsigned pending;





	mdp_irq_unregister(&get_kms(crtc)->base, &mdp5_crtc->vblank);

	mdp_irq_unregister(&get_kms(crtc)->base, &mdp5_crtc->vblank);
@@ -409,6 +565,9 @@ static void mdp5_crtc_vblank_irq(struct mdp_irq *irq, uint32_t irqstatus) 
	if (pending & PENDING_FLIP) {

	if (pending & PENDING_FLIP) {

		complete_flip(crtc, NULL);

		complete_flip(crtc, NULL);

	}

	}



	if (pending & PENDING_CURSOR)

		drm_flip_work_commit(&mdp5_crtc->unref_cursor_work, priv->wq);

}

}





static void mdp5_crtc_err_irq(struct mdp_irq *irq, uint32_t irqstatus)

static void mdp5_crtc_err_irq(struct mdp_irq *irq, uint32_t irqstatus)
@@ -508,6 +667,7 @@ struct drm_crtc *mdp5_crtc_init(struct drm_device *dev, 
	mdp5_crtc->lm = GET_LM_ID(id);

	mdp5_crtc->lm = GET_LM_ID(id);





	spin_lock_init(&mdp5_crtc->lm_lock);

	spin_lock_init(&mdp5_crtc->lm_lock);

	spin_lock_init(&mdp5_crtc->cursor.lock);





	mdp5_crtc->vblank.irq = mdp5_crtc_vblank_irq;

	mdp5_crtc->vblank.irq = mdp5_crtc_vblank_irq;

	mdp5_crtc->err.irq = mdp5_crtc_err_irq;

	mdp5_crtc->err.irq = mdp5_crtc_err_irq;
@@ -516,6 +676,10 @@ struct drm_crtc *mdp5_crtc_init(struct drm_device *dev, 
			pipe2name(mdp5_plane_pipe(plane)), id);

			pipe2name(mdp5_plane_pipe(plane)), id);





	drm_crtc_init_with_planes(dev, crtc, plane, NULL, &mdp5_crtc_funcs);

	drm_crtc_init_with_planes(dev, crtc, plane, NULL, &mdp5_crtc_funcs);



	drm_flip_work_init(&mdp5_crtc->unref_cursor_work,

			"unref cursor", unref_cursor_worker);



	drm_crtc_helper_add(crtc, &mdp5_crtc_helper_funcs);

	drm_crtc_helper_add(crtc, &mdp5_crtc_helper_funcs);

	plane->crtc = crtc;

	plane->crtc = crtc;