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

Commit d7969fe3 authored by Ingrid Gallardo's avatar Ingrid Gallardo
Browse files

drm/msm/sde: remove inline rotator v1 rm 



Remove resource manager functions for
inline rotator v1.

Change-Id: Ia3b7e1ac8e70124ea4af425e8b0c7132a1066a3a
Signed-off-by: default avatarIngrid Gallardo <ingridg@codeaurora.org>
parent 0e2d5150

drivers/gpu/drm/msm/Makefile

+0 −1
Original line number Diff line number Diff line
@@ -174,7 +174,6 @@ msm_drm-$(CONFIG_DRM_MSM_SDE) += \ 
	sde/sde_hw_util.o \

	sde/sde_hw_sspp.o \

	sde/sde_hw_wb.o \

	sde/sde_hw_rot.o \

	sde/sde_hw_pingpong.o \

	sde/sde_hw_top.o \

	sde/sde_hw_interrupts.o \

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

+0 −494
Original line number Diff line number Diff line
@@ -185,476 +185,6 @@ static void sde_crtc_calc_fps(struct sde_crtc *sde_crtc) 
	sde_crtc->fps_info.next_time_index %= MAX_FRAME_COUNT;

}



/**

 * _sde_crtc_rp_to_crtc - get crtc from resource pool object

 * @rp: Pointer to resource pool

 * return: Pointer to drm crtc if success; null otherwise

 */

static struct drm_crtc *_sde_crtc_rp_to_crtc(struct sde_crtc_respool *rp)

{

	if (!rp)

		return NULL;



	return container_of(rp, struct sde_crtc_state, rp)->base.crtc;

}



/**

 * _sde_crtc_rp_reclaim - reclaim unused, or all if forced, resources in pool

 * @rp: Pointer to resource pool

 * @force: True to reclaim all resources; otherwise, reclaim only unused ones

 * return: None

 */

static void _sde_crtc_rp_reclaim(struct sde_crtc_respool *rp, bool force)

{

	struct sde_crtc_res *res, *next;

	struct drm_crtc *crtc;



	crtc = _sde_crtc_rp_to_crtc(rp);

	if (!crtc) {

		SDE_ERROR("invalid crtc\n");

		return;

	}



	SDE_DEBUG("crtc%d.%u %s\n", crtc->base.id, rp->sequence_id,

			force ? "destroy" : "free_unused");



	list_for_each_entry_safe(res, next, &rp->res_list, list) {

		if (!force && !(res->flags & SDE_CRTC_RES_FLAG_FREE))

			continue;

		SDE_DEBUG("crtc%d.%u reclaim res:0x%x/0x%llx/%pK/%d\n",

				crtc->base.id, rp->sequence_id,

				res->type, res->tag, res->val,

				atomic_read(&res->refcount));

		list_del(&res->list);

		if (res->ops.put)

			res->ops.put(res->val);

		kfree(res);

	}

}



/**

 * _sde_crtc_rp_free_unused - free unused resource in pool

 * @rp: Pointer to resource pool

 * return: none

 */

static void _sde_crtc_rp_free_unused(struct sde_crtc_respool *rp)

{

	mutex_lock(rp->rp_lock);

	_sde_crtc_rp_reclaim(rp, false);

	mutex_unlock(rp->rp_lock);

}



/**

 * _sde_crtc_rp_destroy - destroy resource pool

 * @rp: Pointer to resource pool

 * return: None

 */

static void _sde_crtc_rp_destroy(struct sde_crtc_respool *rp)

{

	mutex_lock(rp->rp_lock);

	list_del_init(&rp->rp_list);

	_sde_crtc_rp_reclaim(rp, true);

	mutex_unlock(rp->rp_lock);

}



/**

 * _sde_crtc_hw_blk_get - get callback for hardware block

 * @val: Resource handle

 * @type: Resource type

 * @tag: Search tag for given resource

 * return: Resource handle

 */

static void *_sde_crtc_hw_blk_get(void *val, u32 type, u64 tag)

{

	SDE_DEBUG("res:%d/0x%llx/%pK\n", type, tag, val);

	return sde_hw_blk_get(val, type, tag);

}



/**

 * _sde_crtc_hw_blk_put - put callback for hardware block

 * @val: Resource handle

 * return: None

 */

static void _sde_crtc_hw_blk_put(void *val)

{

	SDE_DEBUG("res://%pK\n", val);

	sde_hw_blk_put(val);

}



/**

 * _sde_crtc_rp_duplicate - duplicate resource pool and reset reference count

 * @rp: Pointer to original resource pool

 * @dup_rp: Pointer to duplicated resource pool

 * return: None

 */

static void _sde_crtc_rp_duplicate(struct sde_crtc_respool *rp,

		struct sde_crtc_respool *dup_rp)

{

	struct sde_crtc_res *res, *dup_res;

	struct drm_crtc *crtc;



	if (!rp || !dup_rp || !rp->rp_head) {

		SDE_ERROR("invalid resource pool\n");

		return;

	}



	crtc = _sde_crtc_rp_to_crtc(rp);

	if (!crtc) {

		SDE_ERROR("invalid crtc\n");

		return;

	}



	SDE_DEBUG("crtc%d.%u duplicate\n", crtc->base.id, rp->sequence_id);



	mutex_lock(rp->rp_lock);

	dup_rp->sequence_id = rp->sequence_id + 1;

	INIT_LIST_HEAD(&dup_rp->res_list);

	dup_rp->ops = rp->ops;

	list_for_each_entry(res, &rp->res_list, list) {

		dup_res = kzalloc(sizeof(struct sde_crtc_res), GFP_KERNEL);

		if (!dup_res) {

			mutex_unlock(rp->rp_lock);

			return;

		}

		INIT_LIST_HEAD(&dup_res->list);

		atomic_set(&dup_res->refcount, 0);

		dup_res->type = res->type;

		dup_res->tag = res->tag;

		dup_res->val = res->val;

		dup_res->ops = res->ops;

		dup_res->flags = SDE_CRTC_RES_FLAG_FREE;

		SDE_DEBUG("crtc%d.%u dup res:0x%x/0x%llx/%pK/%d\n",

				crtc->base.id, dup_rp->sequence_id,

				dup_res->type, dup_res->tag, dup_res->val,

				atomic_read(&dup_res->refcount));

		list_add_tail(&dup_res->list, &dup_rp->res_list);

		if (dup_res->ops.get)

			dup_res->ops.get(dup_res->val, 0, -1);

	}



	dup_rp->rp_lock = rp->rp_lock;

	dup_rp->rp_head = rp->rp_head;

	INIT_LIST_HEAD(&dup_rp->rp_list);

	list_add_tail(&dup_rp->rp_list, rp->rp_head);

	mutex_unlock(rp->rp_lock);

}



/**

 * _sde_crtc_rp_reset - reset resource pool after allocation

 * @rp: Pointer to original resource pool

 * @rp_lock: Pointer to serialization resource pool lock

 * @rp_head: Pointer to crtc resource pool head

 * return: None

 */

static void _sde_crtc_rp_reset(struct sde_crtc_respool *rp,

		struct mutex *rp_lock, struct list_head *rp_head)

{

	if (!rp || !rp_lock || !rp_head) {

		SDE_ERROR("invalid resource pool\n");

		return;

	}



	mutex_lock(rp_lock);

	rp->rp_lock = rp_lock;

	rp->rp_head = rp_head;

	INIT_LIST_HEAD(&rp->rp_list);

	rp->sequence_id = 0;

	INIT_LIST_HEAD(&rp->res_list);

	rp->ops.get = _sde_crtc_hw_blk_get;

	rp->ops.put = _sde_crtc_hw_blk_put;

	list_add_tail(&rp->rp_list, rp->rp_head);

	mutex_unlock(rp_lock);

}



/**

 * _sde_crtc_rp_add_no_lock - add given resource to resource pool without lock

 * @rp: Pointer to original resource pool

 * @type: Resource type

 * @tag: Search tag for given resource

 * @val: Resource handle

 * @ops: Resource callback operations

 * return: 0 if success; error code otherwise

 */

static int _sde_crtc_rp_add_no_lock(struct sde_crtc_respool *rp, u32 type,

		u64 tag, void *val, struct sde_crtc_res_ops *ops)

{

	struct sde_crtc_res *res;

	struct drm_crtc *crtc;



	if (!rp || !ops) {

		SDE_ERROR("invalid resource pool/ops\n");

		return -EINVAL;

	}



	crtc = _sde_crtc_rp_to_crtc(rp);

	if (!crtc) {

		SDE_ERROR("invalid crtc\n");

		return -EINVAL;

	}



	list_for_each_entry(res, &rp->res_list, list) {

		if (res->type != type || res->tag != tag)

			continue;

		SDE_ERROR("crtc%d.%u already exist res:0x%x/0x%llx/%pK/%d\n",

				crtc->base.id, rp->sequence_id,

				res->type, res->tag, res->val,

				atomic_read(&res->refcount));

		return -EEXIST;

	}

	res = kzalloc(sizeof(struct sde_crtc_res), GFP_KERNEL);

	if (!res)

		return -ENOMEM;

	INIT_LIST_HEAD(&res->list);

	atomic_set(&res->refcount, 1);

	res->type = type;

	res->tag = tag;

	res->val = val;

	res->ops = *ops;

	list_add_tail(&res->list, &rp->res_list);

	SDE_DEBUG("crtc%d.%u added res:0x%x/0x%llx\n",

			crtc->base.id, rp->sequence_id, type, tag);

	return 0;

}



/**

 * _sde_crtc_rp_add - add given resource to resource pool

 * @rp: Pointer to original resource pool

 * @type: Resource type

 * @tag: Search tag for given resource

 * @val: Resource handle

 * @ops: Resource callback operations

 * return: 0 if success; error code otherwise

 */

static int _sde_crtc_rp_add(struct sde_crtc_respool *rp, u32 type, u64 tag,

		void *val, struct sde_crtc_res_ops *ops)

{

	int rc;



	if (!rp) {

		SDE_ERROR("invalid resource pool\n");

		return -EINVAL;

	}



	mutex_lock(rp->rp_lock);

	rc = _sde_crtc_rp_add_no_lock(rp, type, tag, val, ops);

	mutex_unlock(rp->rp_lock);

	return rc;

}



/**

 * _sde_crtc_rp_get - lookup the resource from given resource pool and obtain

 *	if available; otherwise, obtain resource from global pool

 * @rp: Pointer to original resource pool

 * @type: Resource type

 * @tag:  Search tag for given resource

 * return: Resource handle if success; pointer error or null otherwise

 */

static void *_sde_crtc_rp_get(struct sde_crtc_respool *rp, u32 type, u64 tag)

{

	struct sde_crtc_respool *old_rp;

	struct sde_crtc_res *res;

	void *val = NULL;

	int rc;

	struct drm_crtc *crtc;



	if (!rp) {

		SDE_ERROR("invalid resource pool\n");

		return NULL;

	}



	crtc = _sde_crtc_rp_to_crtc(rp);

	if (!crtc) {

		SDE_ERROR("invalid crtc\n");

		return NULL;

	}



	mutex_lock(rp->rp_lock);

	list_for_each_entry(res, &rp->res_list, list) {

		if (res->type != type || res->tag != tag)

			continue;

		SDE_DEBUG("crtc%d.%u found res:0x%x/0x%llx/%pK/%d\n",

				crtc->base.id, rp->sequence_id,

				res->type, res->tag, res->val,

				atomic_read(&res->refcount));

		atomic_inc(&res->refcount);

		res->flags &= ~SDE_CRTC_RES_FLAG_FREE;

		mutex_unlock(rp->rp_lock);

		return res->val;

	}

	list_for_each_entry(res, &rp->res_list, list) {

		if (res->type != type || !(res->flags & SDE_CRTC_RES_FLAG_FREE))

			continue;

		SDE_DEBUG("crtc%d.%u retag res:0x%x/0x%llx/%pK/%d\n",

				crtc->base.id, rp->sequence_id,

				res->type, res->tag, res->val,

				atomic_read(&res->refcount));

		atomic_inc(&res->refcount);

		res->tag = tag;

		res->flags &= ~SDE_CRTC_RES_FLAG_FREE;

		mutex_unlock(rp->rp_lock);

		return res->val;

	}

	/* not in this rp, try to grab from global pool */

	if (rp->ops.get)

		val = rp->ops.get(NULL, type, -1);

	if (!IS_ERR_OR_NULL(val))

		goto add_res;

	/*

	 * Search older resource pools for hw blk with matching type,

	 * necessary when resource is being used by this object,

	 * but in previous states not yet cleaned up.

	 *

	 * This enables searching of all resources currently owned

	 * by this crtc even though the resource might not be used

	 * in the current atomic state. This allows those resources

	 * to be re-acquired by the new atomic state immediately

	 * without waiting for the resources to be fully released.

	 */

	else if (IS_ERR_OR_NULL(val) && (type < SDE_HW_BLK_MAX)) {

		list_for_each_entry(old_rp, rp->rp_head, rp_list) {

			if (old_rp == rp)

				continue;



			list_for_each_entry(res, &old_rp->res_list, list) {

				if (res->type != type)

					continue;

				SDE_DEBUG(

					"crtc%d.%u found res:0x%x//%pK/ in crtc%d.%d\n",

						crtc->base.id,

						rp->sequence_id,

						res->type, res->val,

						crtc->base.id,

						old_rp->sequence_id);

				SDE_EVT32_VERBOSE(crtc->base.id,

						rp->sequence_id,

						res->type, res->val,

						crtc->base.id,

						old_rp->sequence_id);

				if (res->ops.get)

					res->ops.get(res->val, 0, -1);

				val = res->val;

				break;

			}



			if (!IS_ERR_OR_NULL(val))

				break;

		}

	}

	if (IS_ERR_OR_NULL(val)) {

		SDE_DEBUG("crtc%d.%u failed to get res:0x%x//\n",

				crtc->base.id, rp->sequence_id, type);

		mutex_unlock(rp->rp_lock);

		return NULL;

	}

add_res:

	rc = _sde_crtc_rp_add_no_lock(rp, type, tag, val, &rp->ops);

	if (rc) {

		SDE_ERROR("crtc%d.%u failed to add res:0x%x/0x%llx\n",

				crtc->base.id, rp->sequence_id, type, tag);

		if (rp->ops.put)

			rp->ops.put(val);

		val = NULL;

	}

	mutex_unlock(rp->rp_lock);

	return val;

}



/**

 * _sde_crtc_rp_put - return given resource to resource pool

 * @rp: Pointer to original resource pool

 * @type: Resource type

 * @tag: Search tag for given resource

 * return: None

 */

static void _sde_crtc_rp_put(struct sde_crtc_respool *rp, u32 type, u64 tag)

{

	struct sde_crtc_res *res, *next;

	struct drm_crtc *crtc;



	if (!rp) {

		SDE_ERROR("invalid resource pool\n");

		return;

	}



	crtc = _sde_crtc_rp_to_crtc(rp);

	if (!crtc) {

		SDE_ERROR("invalid crtc\n");

		return;

	}



	mutex_lock(rp->rp_lock);

	list_for_each_entry_safe(res, next, &rp->res_list, list) {

		if (res->type != type || res->tag != tag)

			continue;

		SDE_DEBUG("crtc%d.%u found res:0x%x/0x%llx/%pK/%d\n",

				crtc->base.id, rp->sequence_id,

				res->type, res->tag, res->val,

				atomic_read(&res->refcount));

		if (res->flags & SDE_CRTC_RES_FLAG_FREE)

			SDE_ERROR(

				"crtc%d.%u already free res:0x%x/0x%llx/%pK/%d\n",

					crtc->base.id, rp->sequence_id,

					res->type, res->tag, res->val,

					atomic_read(&res->refcount));

		else if (atomic_dec_return(&res->refcount) == 0)

			res->flags |= SDE_CRTC_RES_FLAG_FREE;



		mutex_unlock(rp->rp_lock);

		return;

	}

	SDE_ERROR("crtc%d.%u not found res:0x%x/0x%llx\n",

			crtc->base.id, rp->sequence_id, type, tag);

	mutex_unlock(rp->rp_lock);

}



int sde_crtc_res_add(struct drm_crtc_state *state, u32 type, u64 tag,

		void *val, struct sde_crtc_res_ops *ops)

{

	struct sde_crtc_respool *rp;



	if (!state) {

		SDE_ERROR("invalid parameters\n");

		return -EINVAL;

	}



	rp = &to_sde_crtc_state(state)->rp;

	return _sde_crtc_rp_add(rp, type, tag, val, ops);

}



void *sde_crtc_res_get(struct drm_crtc_state *state, u32 type, u64 tag)

{

	struct sde_crtc_respool *rp;

	void *val;



	if (!state) {

		SDE_ERROR("invalid parameters\n");

		return NULL;

	}



	rp = &to_sde_crtc_state(state)->rp;

	val = _sde_crtc_rp_get(rp, type, tag);

	if (IS_ERR(val)) {

		SDE_ERROR("failed to get res type:0x%x:0x%llx\n",

				type, tag);

		return NULL;

	}



	return val;

}



void sde_crtc_res_put(struct drm_crtc_state *state, u32 type, u64 tag)

{

	struct sde_crtc_respool *rp;



	if (!state) {

		SDE_ERROR("invalid parameters\n");

		return;

	}



	rp = &to_sde_crtc_state(state)->rp;

	_sde_crtc_rp_put(rp, type, tag);

}



static void _sde_crtc_deinit_events(struct sde_crtc *sde_crtc)

{

	if (!sde_crtc)
@@ -3501,8 +3031,6 @@ static void sde_crtc_destroy_state(struct drm_crtc *crtc, 


	SDE_DEBUG("crtc%d\n", crtc->base.id);



	_sde_crtc_rp_destroy(&cstate->rp);



	__drm_atomic_helper_crtc_destroy_state(state);



	/* destroy value helper */
@@ -3948,8 +3476,6 @@ static struct drm_crtc_state *sde_crtc_duplicate_state(struct drm_crtc *crtc) 
	/* duplicate base helper */

	__drm_atomic_helper_crtc_duplicate_state(crtc, &cstate->base);



	_sde_crtc_rp_duplicate(&old_cstate->rp, &cstate->rp);



	return &cstate->base;

}
@@ -4000,9 +3526,6 @@ static void sde_crtc_reset(struct drm_crtc *crtc) 


	_sde_crtc_set_input_fence_timeout(cstate);



	_sde_crtc_rp_reset(&cstate->rp, &sde_crtc->rp_lock,

			&sde_crtc->rp_head);



	cstate->base.crtc = crtc;

	crtc->state = &cstate->base;

}
@@ -4953,7 +4476,6 @@ static int sde_crtc_atomic_check(struct drm_crtc *crtc, 
end:

	kfree(pstates);

	kfree(multirect_plane);

	_sde_crtc_rp_free_unused(&cstate->rp);

	return rc;

}
@@ -5809,8 +5331,6 @@ static int sde_crtc_debugfs_state_show(struct seq_file *s, void *v) 
	struct drm_crtc *crtc = (struct drm_crtc *) s->private;

	struct sde_crtc *sde_crtc = to_sde_crtc(crtc);

	struct sde_crtc_state *cstate = to_sde_crtc_state(crtc->state);

	struct sde_crtc_res *res;

	struct sde_crtc_respool *rp;

	int i;



	seq_printf(s, "num_connectors: %d\n", cstate->num_connectors);
@@ -5828,17 +5348,6 @@ static int sde_crtc_debugfs_state_show(struct seq_file *s, void *v) 
				sde_crtc->cur_perf.max_per_pipe_ib[i]);

	}



	mutex_lock(&sde_crtc->rp_lock);

	list_for_each_entry(rp, &sde_crtc->rp_head, rp_list) {

		seq_printf(s, "rp.%d: ", rp->sequence_id);

		list_for_each_entry(res, &rp->res_list, list)

			seq_printf(s, "0x%x/0x%llx/%pK/%d ",

					res->type, res->tag, res->val,

					atomic_read(&res->refcount));

		seq_puts(s, "\n");

	}

	mutex_unlock(&sde_crtc->rp_lock);



	return 0;

}

DEFINE_SDE_DEBUGFS_SEQ_FOPS(sde_crtc_debugfs_state);
@@ -6165,9 +5674,6 @@ struct drm_crtc *sde_crtc_init(struct drm_device *dev, struct drm_plane *plane) 
	spin_lock_init(&sde_crtc->spin_lock);

	atomic_set(&sde_crtc->frame_pending, 0);



	mutex_init(&sde_crtc->rp_lock);

	INIT_LIST_HEAD(&sde_crtc->rp_head);



	sde_crtc->enabled = false;



	/* Below parameters are for fps calculation for sysfs node */

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

+0 −88
Original line number Diff line number Diff line
@@ -25,7 +25,6 @@ 
#include "sde_fence.h"

#include "sde_kms.h"

#include "sde_core_perf.h"

#include "sde_hw_blk.h"

#include "sde_hw_ds.h"



#define SDE_CRTC_NAME_SIZE	12
@@ -219,8 +218,6 @@ struct sde_crtc_fps_info { 
 * @idle_notify_work: delayed worker to notify idle timeout to user space

 * @power_event   : registered power event handle

 * @cur_perf      : current performance committed to clock/bandwidth driver

 * @rp_lock       : serialization lock for resource pool

 * @rp_head       : list of active resource pool

 * @plane_mask_old: keeps track of the planes used in the previous commit

 */

struct sde_crtc {
@@ -288,9 +285,6 @@ struct sde_crtc { 
	struct sde_core_perf_params cur_perf;

	struct sde_core_perf_params new_perf;



	struct mutex rp_lock;

	struct list_head rp_head;



	u32 plane_mask_old;



	/* blob for histogram data */
@@ -299,56 +293,6 @@ struct sde_crtc { 


#define to_sde_crtc(x) container_of(x, struct sde_crtc, base)



/**

 * struct sde_crtc_res_ops - common operations for crtc resources

 * @get: get given resource

 * @put: put given resource

 */

struct sde_crtc_res_ops {

	void *(*get)(void *val, u32 type, u64 tag);

	void (*put)(void *val);

};



#define SDE_CRTC_RES_FLAG_FREE		BIT(0)



/**

 * struct sde_crtc_res - definition of crtc resources

 * @list: list of crtc resource

 * @type: crtc resource type

 * @tag: unique identifier per type

 * @refcount: reference/usage count

 * @ops: callback operations

 * @val: resource handle associated with type/tag

 * @flags: customization flags

 */

struct sde_crtc_res {

	struct list_head list;

	u32 type;

	u64 tag;

	atomic_t refcount;

	struct sde_crtc_res_ops ops;

	void *val;

	u32 flags;

};



/**

 * sde_crtc_respool - crtc resource pool

 * @rp_lock: pointer to serialization lock

 * @rp_head: pointer to head of active resource pools of this crtc

 * @rp_list: list of crtc resource pool

 * @sequence_id: sequence identifier, incremented per state duplication

 * @res_list: list of resource managed by this resource pool

 * @ops: resource operations for parent resource pool

 */

struct sde_crtc_respool {

	struct mutex *rp_lock;

	struct list_head *rp_head;

	struct list_head rp_list;

	u32 sequence_id;

	struct list_head res_list;

	struct sde_crtc_res_ops ops;

};



/**

 * struct sde_crtc_state - sde container for atomic crtc state

 * @base: Base drm crtc state structure
@@ -405,8 +349,6 @@ struct sde_crtc_state { 
	struct sde_hw_scaler3_lut_cfg scl3_lut_cfg;



	struct sde_core_perf_params new_perf;



	struct sde_crtc_respool rp;

};



enum sde_crtc_irq_state {
@@ -631,36 +573,6 @@ int sde_crtc_event_queue(struct drm_crtc *crtc, 
		void (*func)(struct drm_crtc *crtc, void *usr),

		void *usr, bool color_processing_event);



/**

 * sde_crtc_res_add - add given resource to resource pool in crtc state

 * @state: Pointer to drm crtc state

 * @type: Resource type

 * @tag: Search tag for given resource

 * @val: Resource handle

 * @ops: Resource callback operations

 * return: 0 if success; error code otherwise

 */

int sde_crtc_res_add(struct drm_crtc_state *state, u32 type, u64 tag,

		void *val, struct sde_crtc_res_ops *ops);



/**

 * sde_crtc_res_get - get given resource from resource pool in crtc state

 * @state: Pointer to drm crtc state

 * @type: Resource type

 * @tag: Search tag for given resource

 * return: Resource handle if success; pointer error or null otherwise

 */

void *sde_crtc_res_get(struct drm_crtc_state *state, u32 type, u64 tag);



/**

 * sde_crtc_res_put - return given resource to resource pool in crtc state

 * @state: Pointer to drm crtc state

 * @type: Resource type

 * @tag: Search tag for given resource

 * return: None

 */

void sde_crtc_res_put(struct drm_crtc_state *state, u32 type, u64 tag);



/**

 * sde_crtc_get_crtc_roi - retrieve the crtc_roi from the given state object

 *	used to allow the planes to adjust their final lm out_xy value in the

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

+0 −43
Original line number Diff line number Diff line
@@ -620,8 +620,6 @@ enum sde_clk_ctrl_type { 
	SDE_CLK_CTRL_WB0,

	SDE_CLK_CTRL_WB1,

	SDE_CLK_CTRL_WB2,

	SDE_CLK_CTRL_INLINE_ROT0_SSPP,

	SDE_CLK_CTRL_INLINE_ROT0_WB,

	SDE_CLK_CTRL_MAX,

};
@@ -844,44 +842,6 @@ struct sde_merge_3d_cfg { 
	SDE_HW_BLK_INFO;

};



/**

 * struct sde_rot_vbif_cfg - inline rotator vbif configs

 * @xin_id             xin client id

 * @num                enum identifying this block

 * @is_read            indicates read/write client

 * @clk_ctrl           index to clk control

 */

struct sde_rot_vbif_cfg {

	u32 xin_id;

	u32 num;

	bool is_read;

	enum sde_clk_ctrl_type clk_ctrl;

};



/**

 * struct sde_rot_cfg - information of rotator blocks

 * @id                 enum identifying this block

 * @base               register offset of this block

 * @len                length of hardware block

 * @features           bit mask identifying sub-blocks/features

 * @pdev               private device handle

 * @scid               subcache identifier

 * @slice_size         subcache slice size

 * @vbif_idx           vbif identifier

 * @xin_count          number of xin clients

 * @vbif_cfg           vbif settings related to rotator

 */

struct sde_rot_cfg {

	SDE_HW_BLK_INFO;

	void *pdev;

	int scid;

	size_t slice_size;

	u32 vbif_idx;



	u32 xin_count;

	struct sde_rot_vbif_cfg vbif_cfg[MAX_BLOCKS];

};



/**

 * struct sde_vbif_dynamic_ot_cfg - dynamic OT setting

 * @pps                pixel per seconds
@@ -1164,9 +1124,6 @@ struct sde_mdss_cfg { 
	u32 wb_count;

	struct sde_wb_cfg wb[MAX_BLOCKS];



	u32 rot_count;

	struct sde_rot_cfg rot[MAX_BLOCKS];



	u32 vbif_count;

	struct sde_vbif_cfg vbif[MAX_BLOCKS];

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

+0 −8
Original line number Diff line number Diff line
@@ -103,7 +103,6 @@ enum sde_hw_blk_type { 
	SDE_HW_BLK_INTF,

	SDE_HW_BLK_WB,

	SDE_HW_BLK_DSC,

	SDE_HW_BLK_ROT,

	SDE_HW_BLK_MERGE_3D,

	SDE_HW_BLK_MAX,

};
@@ -305,13 +304,6 @@ enum sde_rot { 
	ROT_MAX

};



enum sde_inline_rot {

	INLINE_ROT_NONE,

	INLINE_ROT0_SSPP,

	INLINE_ROT0_WB,

	INLINE_ROT_MAX

};



enum sde_merge_3d {

	MERGE_3D_0 = 1,

	MERGE_3D_1,