[PATCH 17/25] drm/msm/dpu: remove RM HW block list iterator

Jeykumar Sankaran
2018-10-09T04:27:34Z

Replacing with simpler linked list helper iterators.

Signed-off-by: Jeykumar Sankaran <jsanka@codeaurora.org>
---
drivers/gpu/drm/msm/disp/dpu1/dpu_rm.c | 120 +++++++++++++--------------------
1 file changed, 46 insertions(+), 74 deletions(-)

diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_rm.c b/drivers/gpu/drm/msm/disp/dpu1/dpu_rm.c
index 1234991..a79456c 100644
--- a/drivers/gpu/drm/msm/disp/dpu1/dpu_rm.c
+++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_rm.c
@@ -45,49 +45,6 @@ struct dpu_rm_hw_blk {
struct dpu_hw_blk *hw;
};

-/**
- * struct dpu_rm_hw_iter - iterator for use with dpu_rm
- * @blk: dpu_rm internal block representation. Clients ignore. Used as iterator.
- * @type: Hardware Block Type client wishes to search for.
- */
-struct dpu_rm_hw_iter {
- struct dpu_rm_hw_blk *blk;
- enum dpu_hw_blk_type type;
-};
-
-static void _dpu_rm_init_hw_iter(
- struct dpu_rm_hw_iter *iter,
- enum dpu_hw_blk_type type)
-{
- memset(iter, 0, sizeof(*iter));
- iter->type = type;
-}
-
-static bool _dpu_rm_get_hw_locked(struct dpu_rm *rm, struct dpu_rm_hw_iter *i)
-{
- struct list_head *blk_list;
-
- if (!rm || !i || i->type >= DPU_HW_BLK_MAX) {
- DPU_ERROR("invalid rm\n");
- return false;
- }
-
- blk_list = &rm->hw_blks[i->type];
-
- if (i->blk && (&i->blk->list == blk_list)) {
- DPU_DEBUG("attempt resume iteration past last\n");
- return false;
- }
-
- i->blk = list_prepare_entry(i->blk, blk_list, list);
-
- list_for_each_entry_continue(i->blk, blk_list, list)
- if (!i->blk->in_use)
- return true;
-
- return false;
-}
-
static void _dpu_rm_hw_destroy(enum dpu_hw_blk_type type, void *hw)
{
switch (type) {
@@ -301,7 +258,8 @@ static bool _dpu_rm_check_lm_and_get_connected_blks(
struct dpu_rm_hw_blk *primary_lm)
{
const struct dpu_lm_cfg *lm_cfg = to_dpu_hw_mixer(lm->hw)->cap;
- struct dpu_rm_hw_iter iter;
+ struct dpu_rm_hw_blk *iter;
+ struct list_head *blk_list = &rm->hw_blks[DPU_HW_BLK_PINGPONG];

*pp = NULL;

@@ -320,10 +278,12 @@ static bool _dpu_rm_check_lm_and_get_connected_blks(
}
}

- _dpu_rm_init_hw_iter(&iter, DPU_HW_BLK_PINGPONG);
- while (_dpu_rm_get_hw_locked(rm, &iter)) {
- if (iter.blk->hw->id == lm_cfg->pingpong) {
- *pp = iter.blk;
+ list_for_each_entry(iter, blk_list, list) {
+ if (iter->in_use)
+ continue;
+
+ if (iter->hw->id == lm_cfg->pingpong) {
+ *pp = iter;
break;
}
}
@@ -343,7 +303,8 @@ static int _dpu_rm_reserve_lms(struct dpu_rm *rm,
{
struct dpu_rm_hw_blk *lm[MAX_BLOCKS];
struct dpu_rm_hw_blk *pp[MAX_BLOCKS];
- struct dpu_rm_hw_iter iter_i, iter_j;
+ struct dpu_rm_hw_blk *iter_i, *iter_j;
+ struct list_head *blk_list = &rm->hw_blks[DPU_HW_BLK_LM];
int lm_count = 0;
int i, rc = 0;

@@ -353,14 +314,18 @@ static int _dpu_rm_reserve_lms(struct dpu_rm *rm,
}

/* Find a primary mixer */
- _dpu_rm_init_hw_iter(&iter_i, DPU_HW_BLK_LM);
- while (lm_count != reqs->topology.num_lm &&
- _dpu_rm_get_hw_locked(rm, &iter_i)) {
+ list_for_each_entry(iter_i, blk_list, list) {
+ if (iter_i->in_use)
+ continue;
+
+ if (lm_count == reqs->topology.num_lm)
+ break;
+
memset(&lm, 0, sizeof(lm));
memset(&pp, 0, sizeof(pp));

lm_count = 0;
- lm[lm_count] = iter_i.blk;
+ lm[lm_count] = iter_i;

if (!_dpu_rm_check_lm_and_get_connected_blks(
rm, reqs, lm[lm_count],
@@ -370,19 +335,22 @@ static int _dpu_rm_reserve_lms(struct dpu_rm *rm,
++lm_count;

/* Valid primary mixer found, find matching peers */
- _dpu_rm_init_hw_iter(&iter_j, DPU_HW_BLK_LM);
+ list_for_each_entry(iter_j, blk_list, list) {
+ if (iter_j->in_use)
+ continue;

- while (lm_count != reqs->topology.num_lm &&
- _dpu_rm_get_hw_locked(rm, &iter_j)) {
- if (iter_i.blk == iter_j.blk)
+ if (lm_count == reqs->topology.num_lm)
+ break;
+
+ if (iter_i == iter_j)
continue;

if (!_dpu_rm_check_lm_and_get_connected_blks(
- rm, reqs, iter_j.blk,
- &pp[lm_count], iter_i.blk))
+ rm, reqs, iter_j,
+ &pp[lm_count], iter_i))
continue;

- lm[lm_count] = iter_j.blk;
+ lm[lm_count] = iter_j;
++lm_count;
}
}
@@ -417,7 +385,9 @@ static int _dpu_rm_reserve_ctls(
const struct msm_display_topology *top)
{
struct dpu_rm_hw_blk *ctls[MAX_BLOCKS];
- struct dpu_rm_hw_iter iter;
+ struct dpu_rm_hw_blk *iter;
+ struct list_head *blk_list = &rm->hw_blks[DPU_HW_BLK_CTL];
+
int i = 0, num_ctls = 0;
bool needs_split_display = false;

@@ -428,21 +398,23 @@ static int _dpu_rm_reserve_ctls(

needs_split_display = _dpu_rm_needs_split_display(top);

- _dpu_rm_init_hw_iter(&iter, DPU_HW_BLK_CTL);
- while (_dpu_rm_get_hw_locked(rm, &iter)) {
- const struct dpu_hw_ctl *ctl = to_dpu_hw_ctl(iter.blk->hw);
+ list_for_each_entry(iter, blk_list, list) {
+ const struct dpu_hw_ctl *ctl = to_dpu_hw_ctl(iter->hw);
unsigned long features = ctl->caps->features;
bool has_split_display;

+ if (iter->in_use)
+ continue;
+
has_split_display = BIT(DPU_CTL_SPLIT_DISPLAY) & features;

- DPU_DEBUG("ctl %d caps 0x%lX\n", iter.blk->hw->id, features);
+ DPU_DEBUG("ctl %d caps 0x%lX\n", iter->hw->id, features);

if (needs_split_display != has_split_display)
continue;

- ctls[i] = iter.blk;
- DPU_DEBUG("ctl %d match\n", iter.blk->hw->id);
+ ctls[i] = iter;
+ DPU_DEBUG("ctl %d match\n", iter->hw->id);

if (++i == num_ctls)
break;
@@ -468,26 +440,26 @@ static struct dpu_rm_hw_blk *_dpu_rm_reserve_intf(
uint32_t id,
enum dpu_hw_blk_type type)
{
- struct dpu_rm_hw_iter iter;
+ struct dpu_rm_hw_blk *iter;
+ struct list_head *blk_list = &rm->hw_blks[DPU_HW_BLK_INTF];

/* Find the block entry in the rm, and note the reservation */
- _dpu_rm_init_hw_iter(&iter, type);
- while (_dpu_rm_get_hw_locked(rm, &iter)) {
- if (iter.blk->hw->id != id)
+ list_for_each_entry(iter, blk_list, list) {
+ if (iter->hw->id != id || iter->in_use)
continue;

- trace_dpu_rm_reserve_intf(iter.blk->hw->id, DPU_HW_BLK_INTF);
+ trace_dpu_rm_reserve_intf(iter->hw->id, DPU_HW_BLK_INTF);

break;
}

/* Shouldn't happen since intfs are fixed at probe */
- if (!iter.blk) {
+ if (!iter) {
DPU_ERROR("couldn't find type %d id %d\n", type, id);
return NULL;
}

- return iter.blk;
+ return iter;
}

static int _dpu_rm_reserve_intf_related_hw(
--
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,
a Linux Foundation Collaborative Project