disp: msm: sde: remove sde_hw_blk

The sde_hw_blk was meant to be a generic base object for all
SDE HW blocks, however, it enforces using a common set of ops
which is not practical when blocks have different capabilities.
Since this object was never used as intended and is not doing
anything functional today, remove the dead weight.

Change-Id: If76006c1ae5c62e8d7d77b100837dbaf6c661bd3
Signed-off-by: Steve Cohen <[email protected]>

msm/Kbuild

@@ -159,7 +159,6 @@ msm_drm-$(CONFIG_DRM_MSM_SDE) += sde/sde_crtc.o \
 				 sde/sde_hw_top.o \
 				 sde/sde_hw_interrupts.o \
 				 sde/sde_hw_vbif.o \
-				 sde/sde_hw_blk.o \
 				 sde/sde_formats.o \
 				 sde_power_handle.o \
 				 sde/sde_hw_color_processing_v1_7.o \

msm/sde/sde_crtc.c

@@ -30,6 +30,7 @@
 #include "sde_kms.h"
 #include "sde_hw_lm.h"
 #include "sde_hw_ctl.h"
+#include "sde_hw_dspp.h"
 #include "sde_crtc.h"
 #include "sde_plane.h"
 #include "sde_hw_util.h"
@@ -3386,7 +3387,7 @@ static void _sde_crtc_setup_mixer_for_encoder(
 
 		if (!sde_rm_get_hw(rm, &lm_iter))
 			break;
-		mixer->hw_lm = (struct sde_hw_mixer *)lm_iter.hw;
+		mixer->hw_lm = to_sde_hw_mixer(lm_iter.hw);
 
 		/* CTL may be <= LMs, if <, multiple LMs controlled by 1 CTL */
 		if (!sde_rm_get_hw(rm, &ctl_iter)) {
@@ -3394,7 +3395,7 @@ static void _sde_crtc_setup_mixer_for_encoder(
 					mixer->hw_lm->idx - LM_0);
 			mixer->hw_ctl = last_valid_ctl;
 		} else {
-			mixer->hw_ctl = (struct sde_hw_ctl *)ctl_iter.hw;
+			mixer->hw_ctl = to_sde_hw_ctl(ctl_iter.hw);
 			last_valid_ctl = mixer->hw_ctl;
 			sde_crtc->num_ctls++;
 		}
@@ -3408,11 +3409,11 @@ static void _sde_crtc_setup_mixer_for_encoder(
 
 		/* Dspp may be null */
 		(void) sde_rm_get_hw(rm, &dspp_iter);
-		mixer->hw_dspp = (struct sde_hw_dspp *)dspp_iter.hw;
+		mixer->hw_dspp = to_sde_hw_dspp(dspp_iter.hw);
 
 		/* DS may be null */
 		(void) sde_rm_get_hw(rm, &ds_iter);
-		mixer->hw_ds = (struct sde_hw_ds *)ds_iter.hw;
+		mixer->hw_ds = to_sde_hw_ds(ds_iter.hw);
 
 		mixer->encoder = enc;
 

msm/sde/sde_encoder.c

@@ -35,6 +35,7 @@
 #include "sde_encoder.h"
 #include "sde_encoder_phys.h"
 #include "sde_hw_dsc.h"
+#include "sde_hw_vdc.h"
 #include "sde_crtc.h"
 #include "sde_trace.h"
 #include "sde_core_irq.h"
@@ -2381,7 +2382,7 @@ static void _sde_encoder_virt_populate_hw_res(struct drm_encoder *drm_enc)
 		sde_enc->hw_pp[i] = NULL;
 		if (!sde_rm_get_hw(&sde_kms->rm, &pp_iter))
 			break;
-		sde_enc->hw_pp[i] = (struct sde_hw_pingpong *) pp_iter.hw;
+		sde_enc->hw_pp[i] = to_sde_hw_pingpong(pp_iter.hw);
 	}
 
 	for (i = 0; i < sde_enc->num_phys_encs; i++) {
@@ -2392,8 +2393,7 @@ static void _sde_encoder_virt_populate_hw_res(struct drm_encoder *drm_enc)
 						SDE_HW_BLK_QDSS);
 			for (j = 0; j < QDSS_MAX; j++) {
 				if (sde_rm_get_hw(&sde_kms->rm, &qdss_iter)) {
-					phys->hw_qdss =
-					(struct sde_hw_qdss *)qdss_iter.hw;
+					phys->hw_qdss = to_sde_hw_qdss(qdss_iter.hw);
 					break;
 				}
 			}
@@ -2405,7 +2405,7 @@ static void _sde_encoder_virt_populate_hw_res(struct drm_encoder *drm_enc)
 		sde_enc->hw_dsc[i] = NULL;
 		if (!sde_rm_get_hw(&sde_kms->rm, &dsc_iter))
 			break;
-		sde_enc->hw_dsc[i] = (struct sde_hw_dsc *) dsc_iter.hw;
+		sde_enc->hw_dsc[i] = to_sde_hw_dsc(dsc_iter.hw);
 	}
 
 	sde_rm_init_hw_iter(&vdc_iter, drm_enc->base.id, SDE_HW_BLK_VDC);
@@ -2413,7 +2413,7 @@ static void _sde_encoder_virt_populate_hw_res(struct drm_encoder *drm_enc)
 		sde_enc->hw_vdc[i] = NULL;
 		if (!sde_rm_get_hw(&sde_kms->rm, &vdc_iter))
 			break;
-		sde_enc->hw_vdc[i] = (struct sde_hw_vdc *) vdc_iter.hw;
+		sde_enc->hw_vdc[i] = to_sde_hw_vdc(vdc_iter.hw);
 	}
 
 	/* Get PP for DSC configuration */
@@ -2424,11 +2424,11 @@ static void _sde_encoder_virt_populate_hw_res(struct drm_encoder *drm_enc)
 		if (!sde_enc->hw_dsc[i])
 			continue;
 
-		request_hw.id = sde_enc->hw_dsc[i]->base.id;
+		request_hw.id = sde_enc->hw_dsc[i]->idx;
 		request_hw.type = SDE_HW_BLK_PINGPONG;
 		if (!sde_rm_request_hw_blk(&sde_kms->rm, &request_hw))
 			break;
-		pp = (struct sde_hw_pingpong *) request_hw.hw;
+		pp = to_sde_hw_pingpong(request_hw.hw);
 		features = pp->ops.get_hw_caps(pp);
 
 		if (test_bit(SDE_PINGPONG_DSC, &features))
@@ -4195,8 +4195,7 @@ static int _helper_flush_qsync(struct sde_encoder_phys *phys_enc)
 		sde_rm_init_hw_iter(&rm_iter, drm_enc->base.id,
 				SDE_HW_BLK_INTF);
 		while (sde_rm_get_hw(&phys_enc->sde_kms->rm, &rm_iter)) {
-			struct sde_hw_intf *hw_intf =
-				(struct sde_hw_intf *)rm_iter.hw;
+			struct sde_hw_intf *hw_intf = to_sde_hw_intf(rm_iter.hw);
 
 			if (!hw_intf)
 				continue;
@@ -4218,8 +4217,7 @@ static int _helper_flush_qsync(struct sde_encoder_phys *phys_enc)
 	} else {
 		sde_rm_init_hw_iter(&rm_iter, drm_enc->base.id, SDE_HW_BLK_LM);
 		while (sde_rm_get_hw(&phys_enc->sde_kms->rm, &rm_iter)) {
-			struct sde_hw_mixer *hw_lm =
-					(struct sde_hw_mixer *)rm_iter.hw;
+			struct sde_hw_mixer *hw_lm = to_sde_hw_mixer(rm_iter.hw);
 
 			if (!hw_lm)
 				continue;
@@ -4553,7 +4551,7 @@ int sde_encoder_helper_reset_mixers(struct sde_encoder_phys *phys_enc,
 
 	sde_rm_init_hw_iter(&lm_iter, drm_enc->base.id, SDE_HW_BLK_LM);
 	while (sde_rm_get_hw(&phys_enc->sde_kms->rm, &lm_iter)) {
-		struct sde_hw_mixer *hw_lm = (struct sde_hw_mixer *)lm_iter.hw;
+		struct sde_hw_mixer *hw_lm = to_sde_hw_mixer(lm_iter.hw);
 
 		if (!hw_lm)
 			continue;
@@ -5444,7 +5442,7 @@ static void _sde_encoder_cache_hw_res_cont_splash(
 		sde_enc->hw_pp[i] = NULL;
 		if (!sde_rm_get_hw(&sde_kms->rm, &pp_iter))
 			break;
-		sde_enc->hw_pp[i] = (struct sde_hw_pingpong *) pp_iter.hw;
+		sde_enc->hw_pp[i] = to_sde_hw_pingpong(pp_iter.hw);
 	}
 
 	sde_rm_init_hw_iter(&dsc_iter, encoder->base.id, SDE_HW_BLK_DSC);
@@ -5452,7 +5450,7 @@ static void _sde_encoder_cache_hw_res_cont_splash(
 		sde_enc->hw_dsc[i] = NULL;
 		if (!sde_rm_get_hw(&sde_kms->rm, &dsc_iter))
 			break;
-		sde_enc->hw_dsc[i] = (struct sde_hw_dsc *) dsc_iter.hw;
+		sde_enc->hw_dsc[i] = to_sde_hw_dsc(dsc_iter.hw);
 	}
 
 	/*
@@ -5467,8 +5465,7 @@ static void _sde_encoder_cache_hw_res_cont_splash(
 				SDE_HW_BLK_CTL);
 		for (i = 0; i < sde_enc->num_phys_encs; i++) {
 			if (sde_rm_get_hw(&sde_kms->rm, &ctl_iter)) {
-				phys_enc->hw_ctl =
-					(struct sde_hw_ctl *) ctl_iter.hw;
+				phys_enc->hw_ctl = to_sde_hw_ctl(ctl_iter.hw);
 				pr_debug("HW CTL intf_idx:%d hw_ctl:[0x%pK]\n",
 					phys_enc->intf_idx, phys_enc->hw_ctl);
 			}
@@ -5482,7 +5479,7 @@ static void _sde_encoder_cache_hw_res_cont_splash(
 		phys->hw_intf = NULL;
 		if (!sde_rm_get_hw(&sde_kms->rm, &intf_iter))
 			break;
-		phys->hw_intf = (struct sde_hw_intf *) intf_iter.hw;
+		phys->hw_intf = to_sde_hw_intf(intf_iter.hw);
 	}
 }
 

msm/sde/sde_encoder_phys_cmd.c

@@ -428,7 +428,7 @@ static void sde_encoder_phys_cmd_mode_set(
 	sde_rm_init_hw_iter(&iter, phys_enc->parent->base.id, SDE_HW_BLK_CTL);
 	for (i = 0; i <= instance; i++) {
 		if (sde_rm_get_hw(rm, &iter))
-			phys_enc->hw_ctl = (struct sde_hw_ctl *)iter.hw;
+			phys_enc->hw_ctl = to_sde_hw_ctl(iter.hw);
 	}
 
 	if (IS_ERR_OR_NULL(phys_enc->hw_ctl)) {
@@ -441,7 +441,7 @@ static void sde_encoder_phys_cmd_mode_set(
 	sde_rm_init_hw_iter(&iter, phys_enc->parent->base.id, SDE_HW_BLK_INTF);
 	for (i = 0; i <= instance; i++) {
 		if (sde_rm_get_hw(rm, &iter))
-			phys_enc->hw_intf = (struct sde_hw_intf *)iter.hw;
+			phys_enc->hw_intf = to_sde_hw_intf(iter.hw);
 	}
 
 	if (IS_ERR_OR_NULL(phys_enc->hw_intf)) {

msm/sde/sde_encoder_phys_vid.c

@@ -633,7 +633,7 @@ static void sde_encoder_phys_vid_mode_set(
 	sde_rm_init_hw_iter(&iter, phys_enc->parent->base.id, SDE_HW_BLK_CTL);
 	for (i = 0; i <= instance; i++) {
 		if (sde_rm_get_hw(rm, &iter))
-			phys_enc->hw_ctl = (struct sde_hw_ctl *)iter.hw;
+			phys_enc->hw_ctl = to_sde_hw_ctl(iter.hw);
 	}
 	if (IS_ERR_OR_NULL(phys_enc->hw_ctl)) {
 		SDE_ERROR_VIDENC(vid_enc, "failed to init ctl, %ld\n",
@@ -645,7 +645,7 @@ static void sde_encoder_phys_vid_mode_set(
 	sde_rm_init_hw_iter(&iter, phys_enc->parent->base.id, SDE_HW_BLK_INTF);
 	for (i = 0; i <= instance; i++) {
 		if (sde_rm_get_hw(rm, &iter))
-			phys_enc->hw_intf = (struct sde_hw_intf *)iter.hw;
+			phys_enc->hw_intf = to_sde_hw_intf(iter.hw);
 	}
 
 	if (IS_ERR_OR_NULL(phys_enc->hw_intf)) {

msm/sde/sde_encoder_phys_wb.c

@@ -1378,7 +1378,7 @@ static void sde_encoder_phys_wb_mode_set(
 	for (i = 0; i <= instance; i++) {
 		sde_rm_get_hw(rm, &iter);
 		if (i == instance)
-			phys_enc->hw_ctl = (struct sde_hw_ctl *) iter.hw;
+			phys_enc->hw_ctl = to_sde_hw_ctl(iter.hw);
 	}
 
 	if (IS_ERR_OR_NULL(phys_enc->hw_ctl)) {
@@ -1394,7 +1394,7 @@ static void sde_encoder_phys_wb_mode_set(
 	for (i = 0; i <= instance; i++) {
 		sde_rm_get_hw(rm, &iter);
 		if (i == instance)
-			phys_enc->hw_cdm = (struct sde_hw_cdm *) iter.hw;
+			phys_enc->hw_cdm = to_sde_hw_cdm(iter.hw);
 	}
 
 	if (IS_ERR(phys_enc->hw_cdm)) {
@@ -2082,7 +2082,7 @@ struct sde_encoder_phys *sde_encoder_phys_wb_init(
 
 		sde_rm_init_hw_iter(&iter, 0, SDE_HW_BLK_WB);
 		while (sde_rm_get_hw(&p->sde_kms->rm, &iter)) {
-			struct sde_hw_wb *hw_wb = (struct sde_hw_wb *)iter.hw;
+			struct sde_hw_wb *hw_wb = to_sde_hw_wb(iter.hw);
 
 			if (hw_wb->idx == p->wb_idx) {
 				wb_enc->hw_wb = hw_wb;

msm/sde/sde_hw_blk.c

@@ -1,71 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-only
-/*
- * Copyright (c) 2017-2019, 2021, The Linux Foundation. All rights reserved.
- */
-
-#define pr_fmt(fmt)	"[drm:%s:%d] " fmt, __func__, __LINE__
-
-#include <linux/mutex.h>
-#include <linux/errno.h>
-#include <linux/slab.h>
-
-#include "sde_hw_mdss.h"
-#include "sde_hw_blk.h"
-
-/* Serialization lock for sde_hw_blk_list */
-static DEFINE_MUTEX(sde_hw_blk_lock);
-
-/* List of all hw block objects */
-static LIST_HEAD(sde_hw_blk_list);
-
-/**
- * sde_hw_blk_init - initialize hw block object
- * @type: hw block type - enum sde_hw_blk_type
- * @id: instance id of the hw block
- * @ops: Pointer to block operations
- * return: 0 if success; error code otherwise
- */
-int sde_hw_blk_init(struct sde_hw_blk *hw_blk, u32 type, int id,
-		struct sde_hw_blk_ops *ops)
-{
-	if (!hw_blk) {
-		pr_err("invalid parameters\n");
-		return -EINVAL;
-	}
-
-	INIT_LIST_HEAD(&hw_blk->list);
-	hw_blk->type = type;
-	hw_blk->id = id;
-	atomic_set(&hw_blk->refcount, 0);
-
-	if (ops)
-		hw_blk->ops = *ops;
-
-	mutex_lock(&sde_hw_blk_lock);
-	list_add(&hw_blk->list, &sde_hw_blk_list);
-	mutex_unlock(&sde_hw_blk_lock);
-
-	return 0;
-}
-
-/**
- * sde_hw_blk_destroy - destroy hw block object.
- * @hw_blk:  pointer to hw block object
- * return: none
- */
-void sde_hw_blk_destroy(struct sde_hw_blk *hw_blk)
-{
-	if (!hw_blk) {
-		pr_err("invalid parameters\n");
-		return;
-	}
-
-	if (atomic_read(&hw_blk->refcount))
-		pr_err("hw_blk:%d.%d invalid refcount\n", hw_blk->type,
-				hw_blk->id);
-
-	mutex_lock(&sde_hw_blk_lock);
-	list_del(&hw_blk->list);
-	mutex_unlock(&sde_hw_blk_lock);
-}
-

msm/sde/sde_hw_blk.h

@@ -1,44 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-only */
-/*
- * Copyright (c) 2017-2019, 2021, The Linux Foundation. All rights reserved.
- */
-
-#ifndef _SDE_HW_BLK_H
-#define _SDE_HW_BLK_H
-
-#include <linux/types.h>
-#include <linux/list.h>
-#include <linux/atomic.h>
-
-struct sde_hw_blk;
-
-/**
- * struct sde_hw_blk_ops - common hardware block operations
- * @start: start operation on first get
- * @stop: stop operation on last put
- */
-struct sde_hw_blk_ops {
-	int (*start)(struct sde_hw_blk *hw_blk);
-	void (*stop)(struct sde_hw_blk *hw_blk);
-};
-
-/**
- * struct sde_hw_blk - definition of hardware block object
- * @list: list of hardware blocks
- * @type: hardware block type
- * @id: instance id
- * @refcount: reference/usage count
- */
-struct sde_hw_blk {
-	struct list_head list;
-	u32 type;
-	int id;
-	atomic_t refcount;
-	struct sde_hw_blk_ops ops;
-};
-
-int sde_hw_blk_init(struct sde_hw_blk *hw_blk, u32 type, int id,
-		struct sde_hw_blk_ops *ops);
-void sde_hw_blk_destroy(struct sde_hw_blk *hw_blk);
-
-#endif /*_SDE_HW_BLK_H */

msm/sde/sde_hw_cdm.c

@@ -299,19 +299,13 @@ static void _setup_cdm_ops(struct sde_hw_cdm_ops *ops,
 		ops->bind_pingpong_blk = sde_hw_cdm_bind_pingpong_blk;
 }
 
-static struct sde_hw_blk_ops sde_hw_ops = {
-	.start = NULL,
-	.stop = NULL,
-};
-
-struct sde_hw_cdm *sde_hw_cdm_init(enum sde_cdm idx,
+struct sde_hw_blk_reg_map *sde_hw_cdm_init(enum sde_cdm idx,
 		void __iomem *addr,
 		struct sde_mdss_cfg *m,
 		struct sde_hw_mdp *hw_mdp)
 {
 	struct sde_hw_cdm *c;
 	struct sde_cdm_cfg *cfg;
-	int rc;
 
 	c = kzalloc(sizeof(*c), GFP_KERNEL);
 	if (!c)
@@ -328,12 +322,6 @@ struct sde_hw_cdm *sde_hw_cdm_init(enum sde_cdm idx,
 	_setup_cdm_ops(&c->ops, c->caps->features);
 	c->hw_mdp = hw_mdp;
 
-	rc = sde_hw_blk_init(&c->base, SDE_HW_BLK_CDM, idx, &sde_hw_ops);
-	if (rc) {
-		SDE_ERROR("failed to init hw blk %d\n", rc);
-		goto blk_init_error;
-	}
-
 	sde_dbg_reg_register_dump_range(SDE_DBG_NAME, cfg->name, c->hw.blk_off,
 			c->hw.blk_off + c->hw.length, c->hw.xin_id);
 
@@ -344,17 +332,11 @@ struct sde_hw_cdm *sde_hw_cdm_init(enum sde_cdm idx,
 	if (!m->trusted_vm_env)
 		sde_hw_cdm_setup_csc_10bit(c, &rgb2yuv_cfg);
 
-	return c;
-
-blk_init_error:
-	kfree(c);
-
-	return ERR_PTR(rc);
+	return &c->hw;
 }
 
-void sde_hw_cdm_destroy(struct sde_hw_cdm *cdm)
+void sde_hw_cdm_destroy(struct sde_hw_blk_reg_map *hw)
 {
-	if (cdm)
-		sde_hw_blk_destroy(&cdm->base);
-	kfree(cdm);
+	if (hw)
+		kfree(to_sde_hw_cdm(hw));
 }

msm/sde/sde_hw_cdm.h

@@ -1,6 +1,6 @@
 /* SPDX-License-Identifier: GPL-2.0-only */
 /*
- * Copyright (c) 2015-2019, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2015-2019, 2021, The Linux Foundation. All rights reserved.
  */
 
 #ifndef _SDE_HW_CDM_H
@@ -8,7 +8,6 @@
 
 #include "sde_hw_mdss.h"
 #include "sde_hw_top.h"
-#include "sde_hw_blk.h"
 
 struct sde_hw_cdm;
 
@@ -99,7 +98,6 @@ struct sde_hw_cdm_ops {
 };
 
 struct sde_hw_cdm {
-	struct sde_hw_blk base;
 	struct sde_hw_blk_reg_map hw;
 
 	/* chroma down */
@@ -114,13 +112,13 @@ struct sde_hw_cdm {
 };
 
 /**
- * sde_hw_cdm - convert base object sde_hw_base to container
- * @hw: Pointer to base hardware block
+ * to_sde_hw_cdm - convert base hw object to sde_hw_cdm container
+ * @hw: Pointer to hardware block register map object
  * return: Pointer to hardware block container
  */
-static inline struct sde_hw_cdm *to_sde_hw_cdm(struct sde_hw_blk *hw)
+static inline struct sde_hw_cdm *to_sde_hw_cdm(struct sde_hw_blk_reg_map *hw)
 {
-	return container_of(hw, struct sde_hw_cdm, base);
+	return container_of(hw, struct sde_hw_cdm, hw);
 }
 
 /**
@@ -131,15 +129,15 @@ static inline struct sde_hw_cdm *to_sde_hw_cdm(struct sde_hw_blk *hw)
  * @m :   pointer to mdss catalog data
  * @hw_mdp:  pointer to mdp top hw driver object
  */
-struct sde_hw_cdm *sde_hw_cdm_init(enum sde_cdm idx,
+struct sde_hw_blk_reg_map *sde_hw_cdm_init(enum sde_cdm idx,
 		void __iomem *addr,
 		struct sde_mdss_cfg *m,
 		struct sde_hw_mdp *hw_mdp);
 
 /**
  * sde_hw_cdm_destroy - destroys CDM driver context
- * @cdm:   pointer to CDM driver context
+ * @hw: Pointer to hardware block register map object
  */
-void sde_hw_cdm_destroy(struct sde_hw_cdm *cdm);
+void sde_hw_cdm_destroy(struct sde_hw_blk_reg_map *hw);
 
 #endif /*_SDE_HW_CDM_H */

msm/sde/sde_hw_ctl.c

@@ -1327,18 +1327,12 @@ static void _setup_ctl_ops(struct sde_hw_ctl_ops *ops,
 		ops->uidle_enable = sde_hw_ctl_uidle_enable;
 };
 
-static struct sde_hw_blk_ops sde_hw_ops = {
-	.start = NULL,
-	.stop = NULL,
-};
-
-struct sde_hw_ctl *sde_hw_ctl_init(enum sde_ctl idx,
+struct sde_hw_blk_reg_map *sde_hw_ctl_init(enum sde_ctl idx,
 		void __iomem *addr,
 		struct sde_mdss_cfg *m)
 {
 	struct sde_hw_ctl *c;
 	struct sde_ctl_cfg *cfg;
-	int rc;
 
 	c = kzalloc(sizeof(*c), GFP_KERNEL);
 	if (!c)
@@ -1357,26 +1351,14 @@ struct sde_hw_ctl *sde_hw_ctl_init(enum sde_ctl idx,
 	c->mixer_count = m->mixer_count;
 	c->mixer_hw_caps = m->mixer;
 
-	rc = sde_hw_blk_init(&c->base, SDE_HW_BLK_CTL, idx, &sde_hw_ops);
-	if (rc) {
-		SDE_ERROR("failed to init hw blk %d\n", rc);
-		goto blk_init_error;
-	}
-
 	sde_dbg_reg_register_dump_range(SDE_DBG_NAME, cfg->name, c->hw.blk_off,
 			c->hw.blk_off + c->hw.length, c->hw.xin_id);
 
-	return c;
-
-blk_init_error:
-	kfree(c);
-
-	return ERR_PTR(rc);
+	return &c->hw;
 }
 
-void sde_hw_ctl_destroy(struct sde_hw_ctl *ctx)
+void sde_hw_ctl_destroy(struct sde_hw_blk_reg_map *hw)
 {
-	if (ctx)
-		sde_hw_blk_destroy(&ctx->base);
-	kfree(ctx);
+	if (hw)
+		kfree(to_sde_hw_ctl(hw));
 }

msm/sde/sde_hw_ctl.h

@@ -10,7 +10,6 @@
 #include "sde_hw_util.h"
 #include "sde_hw_catalog.h"
 #include "sde_hw_sspp.h"
-#include "sde_hw_blk.h"
 
 #define INVALID_CTL_STATUS 0xfffff88e
 #define CTL_MAX_DSPP_COUNT (DSPP_MAX - DSPP_0)
@@ -478,7 +477,6 @@ struct sde_hw_ctl_ops {
  * @ops: operation list
  */
 struct sde_hw_ctl {
-	struct sde_hw_blk base;
 	struct sde_hw_blk_reg_map hw;
 
 	/* ctl path */
@@ -493,13 +491,13 @@ struct sde_hw_ctl {
 };
 
 /**
- * sde_hw_ctl - convert base object sde_hw_base to container
- * @hw: Pointer to base hardware block
+ * to_sde_hw_ctl - convert base hw object to sde_hw_ctl container
+ * @hw: Pointer to hardware block register map object
  * return: Pointer to hardware block container
  */
-static inline struct sde_hw_ctl *to_sde_hw_ctl(struct sde_hw_blk *hw)
+static inline struct sde_hw_ctl *to_sde_hw_ctl(struct sde_hw_blk_reg_map *hw)
 {
-	return container_of(hw, struct sde_hw_ctl, base);
+	return container_of(hw, struct sde_hw_ctl, hw);
 }
 
 /**
@@ -509,14 +507,14 @@ static inline struct sde_hw_ctl *to_sde_hw_ctl(struct sde_hw_blk *hw)
  * @addr: mapped register io address of MDP
  * @m :   pointer to mdss catalog data
  */
-struct sde_hw_ctl *sde_hw_ctl_init(enum sde_ctl idx,
+struct sde_hw_blk_reg_map *sde_hw_ctl_init(enum sde_ctl idx,
 		void __iomem *addr,
 		struct sde_mdss_cfg *m);
 
 /**
  * sde_hw_ctl_destroy(): Destroys ctl driver context
- * should be called to free the context
+ * @hw: Pointer to hardware block register map object
  */
-void sde_hw_ctl_destroy(struct sde_hw_ctl *ctx);
+void sde_hw_ctl_destroy(struct sde_hw_blk_reg_map *hw);
 
 #endif /*_SDE_HW_CTL_H */

msm/sde/sde_hw_ds.c

@@ -80,18 +80,12 @@ static struct sde_ds_cfg *_ds_offset(enum sde_ds ds,
 	return ERR_PTR(-EINVAL);
 }
 
-static struct sde_hw_blk_ops sde_hw_ops = {
-	.start = NULL,
-	.stop = NULL,
-};
-
-struct sde_hw_ds *sde_hw_ds_init(enum sde_ds idx,
+struct sde_hw_blk_reg_map *sde_hw_ds_init(enum sde_ds idx,
 			void __iomem *addr,
 			struct sde_mdss_cfg *m)
 {
 	struct sde_hw_ds *hw_ds;
 	struct sde_ds_cfg *cfg;
-	int rc;
 
 	if (!addr || !m)
 		return ERR_PTR(-EINVAL);
@@ -115,12 +109,6 @@ struct sde_hw_ds *sde_hw_ds_init(enum sde_ds idx,
 	if (m->qseed_hw_rev)
 		hw_ds->scl->version = m->qseed_hw_rev;
 
-	rc = sde_hw_blk_init(&hw_ds->base, SDE_HW_BLK_DS, idx, &sde_hw_ops);
-	if (rc) {
-		SDE_ERROR("failed to init hw blk %d\n", rc);
-		goto blk_init_error;
-	}
-
 	if (cfg->len) {
 		sde_dbg_reg_register_dump_range(SDE_DBG_NAME, cfg->name,
 				hw_ds->hw.blk_off + cfg->base,
@@ -128,18 +116,11 @@ struct sde_hw_ds *sde_hw_ds_init(enum sde_ds idx,
 				hw_ds->hw.xin_id);
 	}
 
-	return hw_ds;
-
-blk_init_error:
-	kfree(hw_ds);
-
-	return ERR_PTR(rc);
-
+	return &hw_ds->hw;
 }
 
-void sde_hw_ds_destroy(struct sde_hw_ds *hw_ds)
+void sde_hw_ds_destroy(struct sde_hw_blk_reg_map *hw)
 {
-	if (hw_ds)
-		sde_hw_blk_destroy(&hw_ds->base);
-	kfree(hw_ds);
+	if (hw)
+		kfree(to_sde_hw_ds(hw));
 }

msm/sde/sde_hw_ds.h

@@ -1,6 +1,6 @@
 /* SPDX-License-Identifier: GPL-2.0-only */
 /*
- * Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2017-2021, The Linux Foundation. All rights reserved.
  */
 
 #ifndef _SDE_HW_DS_H
@@ -9,7 +9,6 @@
 #include "sde_hw_mdss.h"
 #include "sde_hw_util.h"
 #include "sde_hw_catalog.h"
-#include "sde_hw_blk.h"
 
 struct sde_hw_ds;
 
@@ -71,13 +70,22 @@ struct sde_hw_ds_ops {
  * @ops  : Pointer to operations for this DS
  */
 struct sde_hw_ds {
-	struct sde_hw_blk base;
 	struct sde_hw_blk_reg_map hw;
 	enum sde_ds idx;
 	struct sde_ds_cfg *scl;
 	struct sde_hw_ds_ops ops;
 };
 
+/**
+ * to_sde_hw_ds - convert base hw object to sde_hw_ds container
+ * @hw: Pointer to hardware block register map object
+ * return: Pointer to hardware block container
+ */
+static inline struct sde_hw_ds *to_sde_hw_ds(struct sde_hw_blk_reg_map *hw)
+{
+	return container_of(hw, struct sde_hw_ds, hw);
+}
+
 /**
  * sde_hw_ds_init - initializes the destination scaler
  * hw driver object and should be called once before
@@ -87,15 +95,14 @@ struct sde_hw_ds {
  * @m   : MDSS catalog information
  * @Return: pointer to structure or ERR_PTR
  */
-struct sde_hw_ds *sde_hw_ds_init(enum sde_ds idx,
+struct sde_hw_blk_reg_map *sde_hw_ds_init(enum sde_ds idx,
 			void __iomem *addr,
 			struct sde_mdss_cfg *m);
 
 /**
- * sde_hw_ds_destroy - destroys destination scaler
- * driver context
- * @hw_ds:   Pointer to DS context
+ * sde_hw_ds_destroy - destroys destination scaler driver context
+ * @hw: Pointer to hardware block register map object
  */
-void sde_hw_ds_destroy(struct sde_hw_ds *hw_ds);
+void sde_hw_ds_destroy(struct sde_hw_blk_reg_map *hw);
 
 #endif /*_SDE_HW_DS_H */

msm/sde/sde_hw_dsc.c

@@ -212,29 +212,21 @@ static void _setup_dsc_ops(struct sde_hw_dsc_ops *ops,
 		ops->bind_pingpong_blk = sde_hw_dsc_bind_pingpong_blk;
 };
 
-static struct sde_hw_blk_ops sde_hw_ops = {
-	.start = NULL,
-	.stop = NULL,
-};
-
-struct sde_hw_dsc *sde_hw_dsc_init(enum sde_dsc idx,
+struct sde_hw_blk_reg_map *sde_hw_dsc_init(enum sde_dsc idx,
 		void __iomem *addr,
 		struct sde_mdss_cfg *m)
 {
 	struct sde_hw_dsc *c;
 	struct sde_dsc_cfg *cfg;
 	u32 dsc_ctl_offset;
-	int rc = -EINVAL;
 
 	c = kzalloc(sizeof(*c), GFP_KERNEL);
 	if (!c)
 		return ERR_PTR(-ENOMEM);
 
 	cfg = _dsc_offset(idx, m, addr, &c->hw);
-	if (IS_ERR_OR_NULL(cfg)) {
-		kfree(c);
-		return ERR_PTR(-EINVAL);
-	}
+	if (IS_ERR_OR_NULL(cfg))
+		goto error_inv;
 
 	c->idx = idx;
 	c->caps = cfg;
@@ -286,28 +278,19 @@ struct sde_hw_dsc *sde_hw_dsc_init(enum sde_dsc idx,
 				c->hw.xin_id);
 	} else {
 		SDE_ERROR("failed to setup ops\n");
-		goto blk_init_error;
+		goto error_inv;
 	}
 
-	rc = sde_hw_blk_init(&c->base, SDE_HW_BLK_DSC, idx, &sde_hw_ops);
-	if (rc) {
-		SDE_ERROR("failed to init hw blk %d\n", rc);
-		goto blk_init_error;
-	}
-
-
-
-	return c;
+	return &c->hw;
 
-blk_init_error:
+error_inv:
 	kfree(c);
 
-	return ERR_PTR(rc);
+	return ERR_PTR(-EINVAL);
 }
 
-void sde_hw_dsc_destroy(struct sde_hw_dsc *dsc)
+void sde_hw_dsc_destroy(struct sde_hw_blk_reg_map *hw)
 {
-	if (dsc)
-		sde_hw_blk_destroy(&dsc->base);
-	kfree(dsc);
+	if (hw)
+		kfree(to_sde_hw_dsc(hw));
 }

msm/sde/sde_hw_dsc.h

@@ -1,6 +1,6 @@
 /* SPDX-License-Identifier: GPL-2.0-only */
 /*
- * Copyright (c) 2017-2019, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2017-2019, 2021, The Linux Foundation. All rights reserved.
  */
 
 #ifndef _SDE_HW_DSC_H
@@ -9,7 +9,6 @@
 #include "sde_hw_catalog.h"
 #include "sde_hw_mdss.h"
 #include "sde_hw_util.h"
-#include "sde_hw_blk.h"
 
 struct sde_hw_dsc;
 struct msm_display_dsc_info;
@@ -60,7 +59,6 @@ struct sde_hw_dsc_ops {
 };
 
 struct sde_hw_dsc {
-	struct sde_hw_blk base;
 	struct sde_hw_blk_reg_map hw;
 
 	/* dsc */
@@ -72,13 +70,13 @@ struct sde_hw_dsc {
 };
 
 /**
- * sde_hw_dsc - convert base object sde_hw_base to container
- * @hw: Pointer to base hardware block
+ * to_sde_hw_dsc - convert base hw object to sde_hw_dsc container
+ * @hw: Pointer to hardware block register map object
  * return: Pointer to hardware block container
  */
-static inline struct sde_hw_dsc *to_sde_hw_dsc(struct sde_hw_blk *hw)
+static inline struct sde_hw_dsc *to_sde_hw_dsc(struct sde_hw_blk_reg_map *hw)
 {
-	return container_of(hw, struct sde_hw_dsc, base);
+	return container_of(hw, struct sde_hw_dsc, hw);
 }
 
 /**
@@ -89,15 +87,15 @@ static inline struct sde_hw_dsc *to_sde_hw_dsc(struct sde_hw_blk *hw)
  * @m:    Pointer to mdss catalog data
  * Returns: Error code or allocated sde_hw_dsc context
  */
-struct sde_hw_dsc *sde_hw_dsc_init(enum sde_dsc idx,
+struct sde_hw_blk_reg_map *sde_hw_dsc_init(enum sde_dsc idx,
 		void __iomem *addr,
 		struct sde_mdss_cfg *m);
 
 /**
  * sde_hw_dsc_destroy - destroys dsc driver context
  *                      should be called to free the context
- * @dsc:   Pointer to dsc driver context returned by sde_hw_dsc_init
+ * @hw: Pointer to hardware block register map object
  */
-void sde_hw_dsc_destroy(struct sde_hw_dsc *dsc);
+void sde_hw_dsc_destroy(struct sde_hw_blk_reg_map *hw);
 
 #endif /*_SDE_HW_DSC_H */

msm/sde/sde_hw_dspp.c

@@ -376,18 +376,12 @@ static void _setup_dspp_ops(struct sde_hw_dspp *c, unsigned long features)
 	}
 }
 
-static struct sde_hw_blk_ops sde_hw_ops = {
-	.start = NULL,
-	.stop = NULL,
-};
-
-struct sde_hw_dspp *sde_hw_dspp_init(enum sde_dspp idx,
+struct sde_hw_blk_reg_map *sde_hw_dspp_init(enum sde_dspp idx,
 			void __iomem *addr,
 			struct sde_mdss_cfg *m)
 {
 	struct sde_hw_dspp *c;
 	struct sde_dspp_cfg *cfg;
-	int rc;
 	char buf[256];
 
 	if (!addr || !m)
@@ -416,12 +410,6 @@ struct sde_hw_dspp *sde_hw_dspp_init(enum sde_dspp idx,
 	_init_dspp_ops();
 	_setup_dspp_ops(c, c->cap->features);
 
-	rc = sde_hw_blk_init(&c->base, SDE_HW_BLK_DSPP, idx, &sde_hw_ops);
-	if (rc) {
-		SDE_ERROR("failed to init hw blk %d\n", rc);
-		goto blk_init_error;
-	}
-
 	sde_dbg_reg_register_dump_range(SDE_DBG_NAME, cfg->name,
 			c->hw.blk_off + DSPP_VALID_START_OFF,
 			c->hw.blk_off + c->hw.length, c->hw.xin_id);
@@ -458,20 +446,18 @@ struct sde_hw_dspp *sde_hw_dspp_init(enum sde_dspp idx,
 				c->hw.blk_off + cfg->sblk->demura.base +
 				cfg->sblk->demura.len, c->hw.xin_id);
 	}
-	return c;
 
-blk_init_error:
-	kfree(c);
-
-	return ERR_PTR(rc);
+	return &c->hw;
 }
 
-void sde_hw_dspp_destroy(struct sde_hw_dspp *dspp)
+void sde_hw_dspp_destroy(struct sde_hw_blk_reg_map *hw)
 {
-	if (dspp) {
+	struct sde_hw_dspp *dspp;
+
+	if (hw) {
+		dspp = to_sde_hw_dspp(hw);
 		reg_dmav1_deinit_dspp_ops(dspp->idx);
 		reg_dmav1_deinit_ltm_ops(dspp->idx);
-		sde_hw_blk_destroy(&dspp->base);
+		kfree(dspp);
 	}
-	kfree(dspp);
 }

msm/sde/sde_hw_dspp.h

@@ -6,7 +6,6 @@
 #ifndef _SDE_HW_DSPP_H
 #define _SDE_HW_DSPP_H
 
-#include "sde_hw_blk.h"
 
 struct sde_hw_dspp;
 
@@ -309,7 +308,6 @@ struct sde_hw_dspp_ops {
  * @ltm_checksum_support: flag to check if checksum present
  */
 struct sde_hw_dspp {
-	struct sde_hw_blk base;
 	struct sde_hw_blk_reg_map hw;
 
 	/* dspp top */
@@ -326,13 +324,13 @@ struct sde_hw_dspp {
 };
 
 /**
- * sde_hw_dspp - convert base object sde_hw_base to container
- * @hw: Pointer to base hardware block
+ * to_sde_hw_dspp - convert base hw object to sde_hw_dspp container
+ * @hw: Pointer to hardware block register map object
  * return: Pointer to hardware block container
  */
-static inline struct sde_hw_dspp *to_sde_hw_dspp(struct sde_hw_blk *hw)
+static inline struct sde_hw_dspp *to_sde_hw_dspp(struct sde_hw_blk_reg_map *hw)
 {
-	return container_of(hw, struct sde_hw_dspp, base);
+	return container_of(hw, struct sde_hw_dspp, hw);
 }
 
 /**
@@ -342,14 +340,14 @@ static inline struct sde_hw_dspp *to_sde_hw_dspp(struct sde_hw_blk *hw)
  * @addr: Mapped register io address of MDP
  * @Return: pointer to structure or ERR_PTR
  */
-struct sde_hw_dspp *sde_hw_dspp_init(enum sde_dspp idx,
+struct sde_hw_blk_reg_map *sde_hw_dspp_init(enum sde_dspp idx,
 			void __iomem *addr,
 			struct sde_mdss_cfg *m);
 
 /**
  * sde_hw_dspp_destroy(): Destroys DSPP driver context
- * @dspp:   Pointer to DSPP driver context
+ * @hw: Pointer to hardware block register map object
  */
-void sde_hw_dspp_destroy(struct sde_hw_dspp *dspp);
+void sde_hw_dspp_destroy(struct sde_hw_blk_reg_map *hw);
 
 #endif /*_SDE_HW_DSPP_H */

msm/sde/sde_hw_intf.c

@@ -905,18 +905,12 @@ static void _setup_intf_ops(struct sde_hw_intf_ops *ops,
 		ops->get_vsync_timestamp = sde_hw_intf_get_vsync_timestamp;
 }
 
-static struct sde_hw_blk_ops sde_hw_ops = {
-	.start = NULL,
-	.stop = NULL,
-};
-
-struct sde_hw_intf *sde_hw_intf_init(enum sde_intf idx,
+struct sde_hw_blk_reg_map *sde_hw_intf_init(enum sde_intf idx,
 		void __iomem *addr,
 		struct sde_mdss_cfg *m)
 {
 	struct sde_hw_intf *c;
 	struct sde_intf_cfg *cfg;
-	int rc;
 
 	c = kzalloc(sizeof(*c), GFP_KERNEL);
 	if (!c)
@@ -937,27 +931,15 @@ struct sde_hw_intf *sde_hw_intf_init(enum sde_intf idx,
 	c->mdss = m;
 	_setup_intf_ops(&c->ops, c->cap->features);
 
-	rc = sde_hw_blk_init(&c->base, SDE_HW_BLK_INTF, idx, &sde_hw_ops);
-	if (rc) {
-		SDE_ERROR("failed to init hw blk %d\n", rc);
-		goto blk_init_error;
-	}
-
 	sde_dbg_reg_register_dump_range(SDE_DBG_NAME, cfg->name, c->hw.blk_off,
 			c->hw.blk_off + c->hw.length, c->hw.xin_id);
 
-	return c;
-
-blk_init_error:
-	kfree(c);
-
-	return ERR_PTR(rc);
+	return &c->hw;
 }
 
-void sde_hw_intf_destroy(struct sde_hw_intf *intf)
+void sde_hw_intf_destroy(struct sde_hw_blk_reg_map *hw)
 {
-	if (intf)
-		sde_hw_blk_destroy(&intf->base);
-	kfree(intf);
+	if (hw)
+		kfree(to_sde_hw_intf(hw));
 }
 

msm/sde/sde_hw_intf.h

@@ -9,7 +9,6 @@
 #include "sde_hw_catalog.h"
 #include "sde_hw_mdss.h"
 #include "sde_hw_util.h"
-#include "sde_hw_blk.h"
 #include "sde_kms.h"
 
 struct sde_hw_intf;
@@ -236,7 +235,6 @@ struct sde_hw_intf_ops {
 };
 
 struct sde_hw_intf {
-	struct sde_hw_blk base;
 	struct sde_hw_blk_reg_map hw;
 
 	/* intf */
@@ -250,13 +248,13 @@ struct sde_hw_intf {
 };
 
 /**
- * to_sde_hw_intf - convert base object sde_hw_base to container
- * @hw: Pointer to base hardware block
+ * to_sde_hw_intf - convert base hw object to sde_hw_intf container
+ * @hw: Pointer to hardware block register map object
  * return: Pointer to hardware block container
  */
-static inline struct sde_hw_intf *to_sde_hw_intf(struct sde_hw_blk *hw)
+static inline struct sde_hw_intf *to_sde_hw_intf(struct sde_hw_blk_reg_map *hw)
 {
-	return container_of(hw, struct sde_hw_intf, base);
+	return container_of(hw, struct sde_hw_intf, hw);
 }
 
 /**
@@ -266,14 +264,14 @@ static inline struct sde_hw_intf *to_sde_hw_intf(struct sde_hw_blk *hw)
  * @addr: mapped register io address of MDP
  * @m :   pointer to mdss catalog data
  */
-struct sde_hw_intf *sde_hw_intf_init(enum sde_intf idx,
+struct sde_hw_blk_reg_map *sde_hw_intf_init(enum sde_intf idx,
 		void __iomem *addr,
 		struct sde_mdss_cfg *m);
 
 /**
  * sde_hw_intf_destroy(): Destroys INTF driver context
- * @intf:   Pointer to INTF driver context
+ * @hw: Pointer to hardware block register map object
  */
-void sde_hw_intf_destroy(struct sde_hw_intf *intf);
+void sde_hw_intf_destroy(struct sde_hw_blk_reg_map *hw);
 
 #endif /*_SDE_HW_INTF_H */

msm/sde/sde_hw_lm.c

@@ -400,18 +400,12 @@ static void _setup_mixer_ops(struct sde_mdss_cfg *m,
 		ops->setup_noise_layer = sde_hw_lm_setup_noise_layer;
 };
 
-static struct sde_hw_blk_ops sde_hw_ops = {
-	.start = NULL,
-	.stop = NULL,
-};
-
-struct sde_hw_mixer *sde_hw_lm_init(enum sde_lm idx,
+struct sde_hw_blk_reg_map *sde_hw_lm_init(enum sde_lm idx,
 		void __iomem *addr,
 		struct sde_mdss_cfg *m)
 {
 	struct sde_hw_mixer *c;
 	struct sde_lm_cfg *cfg;
-	int rc;
 
 	c = kzalloc(sizeof(*c), GFP_KERNEL);
 	if (!c)
@@ -427,32 +421,21 @@ struct sde_hw_mixer *sde_hw_lm_init(enum sde_lm idx,
 	c->idx = idx;
 	c->cap = cfg;
 
-	rc = sde_hw_blk_init(&c->base, SDE_HW_BLK_LM, idx, &sde_hw_ops);
-	if (rc) {
-		SDE_ERROR("failed to init hw blk %d\n", rc);
-		goto blk_init_error;
-	}
-
-	/* Dummy mixers should not setup ops and not be added to dump range */
+	/* Dummy mixers should not setup ops nor add to dump ranges */
 	if (cfg->dummy_mixer)
-		return c;
+		goto done;
 
 	_setup_mixer_ops(m, &c->ops, c->cap->features);
 
 	sde_dbg_reg_register_dump_range(SDE_DBG_NAME, cfg->name, c->hw.blk_off,
 			c->hw.blk_off + c->hw.length, c->hw.xin_id);
 
-	return c;
-
-blk_init_error:
-	kfree(c);
-
-	return ERR_PTR(rc);
+done:
+	return &c->hw;
 }
 
-void sde_hw_lm_destroy(struct sde_hw_mixer *lm)
+void sde_hw_lm_destroy(struct sde_hw_blk_reg_map *hw)
 {
-	if (lm)
-		sde_hw_blk_destroy(&lm->base);
-	kfree(lm);
+	if (hw)
+		kfree(to_sde_hw_mixer(hw));
 }

msm/sde/sde_hw_lm.h

@@ -1,6 +1,6 @@
 /* SPDX-License-Identifier: GPL-2.0-only */
 /*
- * Copyright (c) 2015-2019, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2015-2019, 2021, The Linux Foundation. All rights reserved.
  */
 
 #ifndef _SDE_HW_LM_H
@@ -8,7 +8,6 @@
 
 #include "sde_hw_mdss.h"
 #include "sde_hw_util.h"
-#include "sde_hw_blk.h"
 
 struct sde_hw_mixer;
 
@@ -88,7 +87,6 @@ struct sde_hw_lm_ops {
 };
 
 struct sde_hw_mixer {
-	struct sde_hw_blk base;
 	struct sde_hw_blk_reg_map hw;
 
 	/* lm */
@@ -105,13 +103,13 @@ struct sde_hw_mixer {
 };
 
 /**
- * to_sde_hw_mixer - convert base object sde_hw_base to container
- * @hw: Pointer to base hardware block
+ * to_sde_hw_mixer - convert base hw object to sde_hw_mixer container
+ * @hw: Pointer to hardware block register map object
  * return: Pointer to hardware block container
  */
-static inline struct sde_hw_mixer *to_sde_hw_mixer(struct sde_hw_blk *hw)
+static inline struct sde_hw_mixer *to_sde_hw_mixer(struct sde_hw_blk_reg_map *hw)
 {
-	return container_of(hw, struct sde_hw_mixer, base);
+	return container_of(hw, struct sde_hw_mixer, hw);
 }
 
 /**
@@ -121,14 +119,14 @@ static inline struct sde_hw_mixer *to_sde_hw_mixer(struct sde_hw_blk *hw)
  * @addr: mapped register io address of MDP
  * @m :   pointer to mdss catalog data
  */
-struct sde_hw_mixer *sde_hw_lm_init(enum sde_lm idx,
+struct sde_hw_blk_reg_map *sde_hw_lm_init(enum sde_lm idx,
 		void __iomem *addr,
 		struct sde_mdss_cfg *m);
 
 /**
  * sde_hw_lm_destroy(): Destroys layer mixer driver context
- * @lm:   Pointer to LM driver context
+ * @hw: Pointer to hardware block register map object
  */
-void sde_hw_lm_destroy(struct sde_hw_mixer *lm);
+void sde_hw_lm_destroy(struct sde_hw_blk_reg_map *hw);
 
 #endif /*_SDE_HW_LM_H */

msm/sde/sde_hw_pingpong.c

@@ -497,18 +497,12 @@ static void _setup_pingpong_ops(struct sde_hw_pingpong_ops *ops,
 	}
 };
 
-static struct sde_hw_blk_ops sde_hw_ops = {
-	.start = NULL,
-	.stop = NULL,
-};
-
-struct sde_hw_pingpong *sde_hw_pingpong_init(enum sde_pingpong idx,
+struct sde_hw_blk_reg_map *sde_hw_pingpong_init(enum sde_pingpong idx,
 		void __iomem *addr,
 		struct sde_mdss_cfg *m)
 {
 	struct sde_hw_pingpong *c;
 	struct sde_pingpong_cfg *cfg;
-	int rc;
 
 	c = kzalloc(sizeof(*c), GFP_KERNEL);
 	if (!c)
@@ -532,12 +526,6 @@ struct sde_hw_pingpong *sde_hw_pingpong_init(enum sde_pingpong idx,
 
 	_setup_pingpong_ops(&c->ops, c->caps);
 
-	rc = sde_hw_blk_init(&c->base, SDE_HW_BLK_PINGPONG, idx, &sde_hw_ops);
-	if (rc) {
-		SDE_ERROR("failed to init hw blk %d\n", rc);
-		goto blk_init_error;
-	}
-
 	sde_dbg_reg_register_dump_range(SDE_DBG_NAME, cfg->name, c->hw.blk_off,
 			c->hw.blk_off + c->hw.length, c->hw.xin_id);
 
@@ -550,18 +538,15 @@ struct sde_hw_pingpong *sde_hw_pingpong_init(enum sde_pingpong idx,
 			c->hw.xin_id);
 	}
 
-	return c;
-
-blk_init_error:
-	kfree(c);
-
-	return ERR_PTR(rc);
+	return &c->hw;
 }
 
-void sde_hw_pingpong_destroy(struct sde_hw_pingpong *pp)
+void sde_hw_pingpong_destroy(struct sde_hw_blk_reg_map *hw)
 {
-	if (pp) {
-		sde_hw_blk_destroy(&pp->base);
+	struct sde_hw_pingpong *pp;
+
+	if (hw) {
+		pp = to_sde_hw_pingpong(hw);
 		kfree(pp->merge_3d);
 		kfree(pp);
 	}

msm/sde/sde_hw_pingpong.h

@@ -9,7 +9,6 @@
 #include "sde_hw_catalog.h"
 #include "sde_hw_mdss.h"
 #include "sde_hw_util.h"
-#include "sde_hw_blk.h"
 #include <drm/msm_drm_pp.h>
 
 struct sde_hw_pingpong;
@@ -147,7 +146,6 @@ struct sde_hw_merge_3d_ops {
 };
 
 struct sde_hw_merge_3d {
-	struct sde_hw_blk base;
 	struct sde_hw_blk_reg_map hw;
 
 	/* merge_3d */
@@ -159,7 +157,6 @@ struct sde_hw_merge_3d {
 };
 
 struct sde_hw_pingpong {
-	struct sde_hw_blk base;
 	struct sde_hw_blk_reg_map hw;
 
 	/* pingpong */
@@ -174,13 +171,13 @@ struct sde_hw_pingpong {
 };
 
 /**
- * sde_hw_pingpong - convert base object sde_hw_base to container
- * @hw: Pointer to base hardware block
+ * to_sde_hw_pingpong - convert base hw object to sde_hw_pingpong container
+ * @hw: Pointer to hardware block register map object
  * return: Pointer to hardware block container
  */
-static inline struct sde_hw_pingpong *to_sde_hw_pingpong(struct sde_hw_blk *hw)
+static inline struct sde_hw_pingpong *to_sde_hw_pingpong(struct sde_hw_blk_reg_map *hw)
 {
-	return container_of(hw, struct sde_hw_pingpong, base);
+	return container_of(hw, struct sde_hw_pingpong, hw);
 }
 
 /**
@@ -191,15 +188,15 @@ static inline struct sde_hw_pingpong *to_sde_hw_pingpong(struct sde_hw_blk *hw)
  * @m:    Pointer to mdss catalog data
  * Returns: Error code or allocated sde_hw_pingpong context
  */
-struct sde_hw_pingpong *sde_hw_pingpong_init(enum sde_pingpong idx,
+struct sde_hw_blk_reg_map *sde_hw_pingpong_init(enum sde_pingpong idx,
 		void __iomem *addr,
 		struct sde_mdss_cfg *m);
 
 /**
  * sde_hw_pingpong_destroy - destroys pingpong driver context
  *	should be called to free the context
- * @pp:   Pointer to PP driver context returned by sde_hw_pingpong_init
+ * @hw: Pointer to hardware block register map object
  */
-void sde_hw_pingpong_destroy(struct sde_hw_pingpong *pp);
+void sde_hw_pingpong_destroy(struct sde_hw_blk_reg_map *hw);
 
 #endif /*_SDE_HW_PINGPONG_H */

msm/sde/sde_hw_qdss.c

@@ -52,18 +52,12 @@ static void _setup_qdss_ops(struct sde_hw_qdss_ops *ops)
 	ops->enable_qdss_events = sde_hw_qdss_enable_qdss_events;
 }
 
-static struct sde_hw_blk_ops sde_hw_ops = {
-	.start = NULL,
-	.stop = NULL,
-};
-
-struct sde_hw_qdss *sde_hw_qdss_init(enum sde_qdss idx,
+struct sde_hw_blk_reg_map *sde_hw_qdss_init(enum sde_qdss idx,
 			void __iomem *addr,
 			struct sde_mdss_cfg *m)
 {
 	struct sde_hw_qdss *c;
 	struct sde_qdss_cfg *cfg;
-	int rc;
 
 	c = kzalloc(sizeof(*c), GFP_KERNEL);
 	if (!c)
@@ -79,22 +73,14 @@ struct sde_hw_qdss *sde_hw_qdss_init(enum sde_qdss idx,
 	c->caps = cfg;
 	_setup_qdss_ops(&c->ops);
 
-	rc = sde_hw_blk_init(&c->base, SDE_HW_BLK_QDSS, idx, &sde_hw_ops);
-	if (rc) {
-		SDE_ERROR("failed to init hw blk %d\n", rc);
-		kfree(c);
-		return ERR_PTR(rc);
-	}
-
 	sde_dbg_reg_register_dump_range(SDE_DBG_NAME, cfg->name, c->hw.blk_off,
 			c->hw.blk_off + c->hw.length, c->hw.xin_id);
 
-	return c;
+	return &c->hw;
 }
 
-void sde_hw_qdss_destroy(struct sde_hw_qdss *qdss)
+void sde_hw_qdss_destroy(struct sde_hw_blk_reg_map *hw)
 {
-	if (qdss)
-		sde_hw_blk_destroy(&qdss->base);
-	kfree(qdss);
+	if (hw)
+		kfree(to_sde_hw_qdss(hw));
 }

msm/sde/sde_hw_qdss.h

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0-only
 /*
- * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2019, 2021, The Linux Foundation. All rights reserved.
  */
 
 #ifndef _SDE_HW_QDSS_H
@@ -8,7 +8,6 @@
 
 #include "sde_hw_catalog.h"
 #include "sde_hw_mdss.h"
-#include "sde_hw_blk.h"
 #include "sde_hw_util.h"
 
 struct sde_hw_qdss;
@@ -26,7 +25,6 @@ struct sde_hw_qdss_ops {
 };
 
 struct sde_hw_qdss {
-	struct sde_hw_blk base;
 	struct sde_hw_blk_reg_map hw;
 
 	/* qdss */
@@ -38,13 +36,13 @@ struct sde_hw_qdss {
 };
 
 /**
- * to_sde_hw_qdss - convert base object sde_hw_base to container
- * @hw: Pointer to base hardware block
+ * to_sde_hw_qdss -  convert base hw object to sde_hw_qdss container
+ * @hw: Pointer to hardware block register map object
  * return: Pointer to hardware block container
  */
-static inline struct sde_hw_qdss *to_sde_hw_qdss(struct sde_hw_blk *hw)
+static inline struct sde_hw_qdss *to_sde_hw_qdss(struct sde_hw_blk_reg_map *hw)
 {
-	return container_of(hw, struct sde_hw_qdss, base);
+	return container_of(hw, struct sde_hw_qdss, hw);
 }
 
 /**
@@ -54,15 +52,15 @@ static inline struct sde_hw_qdss *to_sde_hw_qdss(struct sde_hw_blk *hw)
  * @m:    Pointer to mdss catalog data
  * Returns: Error code or allocated sde_hw_qdss context
  */
-struct sde_hw_qdss *sde_hw_qdss_init(enum sde_qdss idx,
+struct sde_hw_blk_reg_map *sde_hw_qdss_init(enum sde_qdss idx,
 				void __iomem *addr,
 				struct sde_mdss_cfg *m);
 
 /**
  * sde_hw_qdss_destroy - destroys qdss driver context
  *			 should be called to free the context
- * @qdss: Pointer to qdss driver context returned by sde_hw_qdss_init
+ * @hw: Pointer to hardware block register map object
  */
-void sde_hw_qdss_destroy(struct sde_hw_qdss *qdss);
+void sde_hw_qdss_destroy(struct sde_hw_blk_reg_map *hw);
 
 #endif /*_SDE_HW_QDSS_H */

msm/sde/sde_hw_sspp.c

@@ -1506,18 +1506,12 @@ static struct sde_sspp_cfg *_sspp_offset(enum sde_sspp sspp,
 	return ERR_PTR(-ENOMEM);
 }
 
-static struct sde_hw_blk_ops sde_hw_ops = {
-	.start = NULL,
-	.stop = NULL,
-};
-
 struct sde_hw_pipe *sde_hw_sspp_init(enum sde_sspp idx,
 		void __iomem *addr, struct sde_mdss_cfg *catalog,
 		bool is_virtual_pipe)
 {
 	struct sde_hw_pipe *hw_pipe;
 	struct sde_sspp_cfg *cfg;
-	int rc;
 
 	if (!addr || !catalog)
 		return ERR_PTR(-EINVAL);
@@ -1544,12 +1538,6 @@ struct sde_hw_pipe *sde_hw_sspp_init(enum sde_sspp idx,
 		sde_init_scaler_blk(&hw_pipe->cap->sblk->scaler_blk,
 			catalog->qseed_hw_rev);
 
-	rc = sde_hw_blk_init(&hw_pipe->base, SDE_HW_BLK_SSPP, idx, &sde_hw_ops);
-	if (rc) {
-		SDE_ERROR("failed to init hw blk %d\n", rc);
-		goto blk_init_error;
-	}
-
 	if (!is_virtual_pipe) {
 		sde_dbg_reg_register_dump_range(SDE_DBG_NAME, cfg->name,
 			hw_pipe->hw.blk_off,
@@ -1595,17 +1583,11 @@ struct sde_hw_pipe *sde_hw_sspp_init(enum sde_sspp idx,
 			hw_pipe->hw.xin_id);
 
 	return hw_pipe;
-
-blk_init_error:
-	kfree(hw_pipe);
-
-	return ERR_PTR(rc);
 }
 
 void sde_hw_sspp_destroy(struct sde_hw_pipe *ctx)
 {
 	if (ctx) {
-		sde_hw_blk_destroy(&ctx->base);
 		reg_dmav1_deinit_sspp_ops(ctx->idx);
 		kfree(ctx->cap);
 	}

msm/sde/sde_hw_sspp.h

@@ -10,7 +10,6 @@
 #include "sde_hw_mdss.h"
 #include "sde_hw_util.h"
 #include "sde_reg_dma.h"
-#include "sde_hw_blk.h"
 #include "sde_formats.h"
 #include "sde_color_processing.h"
 
@@ -691,7 +690,6 @@ struct sde_hw_sspp_ops {
  * @ops: pointer to operations possible for this pipe
  */
 struct sde_hw_pipe {
-	struct sde_hw_blk base;
 	struct sde_hw_blk_reg_map hw;
 	struct sde_mdss_cfg *catalog;
 	struct sde_mdp_cfg *mdp;
@@ -705,16 +703,6 @@ struct sde_hw_pipe {
 	struct sde_hw_ctl *ctl;
 };
 
-/**
- * sde_hw_pipe - convert base object sde_hw_base to container
- * @hw: Pointer to base hardware block
- * return: Pointer to hardware block container
- */
-static inline struct sde_hw_pipe *to_sde_hw_pipe(struct sde_hw_blk *hw)
-{
-	return container_of(hw, struct sde_hw_pipe, base);
-}
-
 /**
  * sde_hw_sspp_init - initializes the sspp hw driver object.
  * Should be called once before accessing every pipe.

msm/sde/sde_hw_top.c

@@ -558,18 +558,12 @@ static const struct sde_mdp_cfg *_top_offset(enum sde_mdp mdp,
 	return ERR_PTR(-EINVAL);
 }
 
-static struct sde_hw_blk_ops sde_hw_ops = {
-	.start = NULL,
-	.stop = NULL,
-};
-
 struct sde_hw_mdp *sde_hw_mdptop_init(enum sde_mdp idx,
 		void __iomem *addr,
 		const struct sde_mdss_cfg *m)
 {
 	struct sde_hw_mdp *mdp;
 	const struct sde_mdp_cfg *cfg;
-	int rc;
 
 	if (!addr || !m)
 		return ERR_PTR(-EINVAL);
@@ -591,12 +585,6 @@ struct sde_hw_mdp *sde_hw_mdptop_init(enum sde_mdp idx,
 	mdp->caps = cfg;
 	_setup_mdp_ops(&mdp->ops, mdp->caps->features);
 
-	rc = sde_hw_blk_init(&mdp->base, SDE_HW_BLK_TOP, idx, &sde_hw_ops);
-	if (rc) {
-		SDE_ERROR("failed to init hw blk %d\n", rc);
-		goto blk_init_error;
-	}
-
 	sde_dbg_reg_register_dump_range(SDE_DBG_NAME, "mdss_hw", 0,
 			m->mdss_hw_block_size, 0);
 
@@ -618,17 +606,10 @@ struct sde_hw_mdp *sde_hw_mdptop_init(enum sde_mdp idx,
 	sde_dbg_set_sde_top_offset(mdp->hw.blk_off);
 
 	return mdp;
-
-blk_init_error:
-	kfree(mdp);
-
-	return ERR_PTR(rc);
 }
 
 void sde_hw_mdp_destroy(struct sde_hw_mdp *mdp)
 {
-	if (mdp)
-		sde_hw_blk_destroy(&mdp->base);
 	kfree(mdp);
 }
 

msm/sde/sde_hw_top.h

@@ -9,7 +9,6 @@
 #include "sde_hw_catalog.h"
 #include "sde_hw_mdss.h"
 #include "sde_hw_util.h"
-#include "sde_hw_blk.h"
 
 struct sde_hw_mdp;
 
@@ -204,7 +203,6 @@ struct sde_hw_mdp_ops {
 };
 
 struct sde_hw_mdp {
-	struct sde_hw_blk base;
 	struct sde_hw_blk_reg_map hw;
 
 	/* top */
@@ -250,16 +248,6 @@ void sde_hw_set_sspp_sid(struct sde_hw_sid *sid, u32 pipe, u32 vm);
  */
 void sde_hw_set_lutdma_sid(struct sde_hw_sid *sid, u32 vm);
 
-/**
- * to_sde_hw_mdp - convert base object sde_hw_base to container
- * @hw: Pointer to base hardware block
- * return: Pointer to hardware block container
- */
-static inline struct sde_hw_mdp *to_sde_hw_mdp(struct sde_hw_blk *hw)
-{
-	return container_of(hw, struct sde_hw_mdp, base);
-}
-
 /**
  * sde_hw_mdptop_init - initializes the top driver for the passed idx
  * @idx:  Interface index for which driver object is required

msm/sde/sde_hw_vdc.c

@@ -385,18 +385,12 @@ static void _setup_vdc_ops(struct sde_hw_vdc_ops *ops,
 	ops->bind_pingpong_blk = sde_hw_vdc_bind_pingpong_blk;
 }
 
-static struct sde_hw_blk_ops sde_hw_ops = {
-	.start = NULL,
-	.stop = NULL,
-};
-
-struct sde_hw_vdc *sde_hw_vdc_init(enum sde_vdc idx,
+struct sde_hw_blk_reg_map *sde_hw_vdc_init(enum sde_vdc idx,
 		void __iomem *addr,
 		struct sde_mdss_cfg *m)
 {
 	struct sde_hw_vdc *c;
 	struct sde_vdc_cfg *cfg;
-	int rc;
 	u32 vdc_ctl_reg;
 	char blk_name[32];
 
@@ -415,12 +409,6 @@ struct sde_hw_vdc *sde_hw_vdc_init(enum sde_vdc idx,
 
 	_setup_vdc_ops(&c->ops, c->caps->features);
 
-	rc = sde_hw_blk_init(&c->base, SDE_HW_BLK_VDC, idx, &sde_hw_ops);
-	if (rc) {
-		SDE_ERROR("failed to init hw blk %d\n", rc);
-		goto blk_init_error;
-	}
-
 	if (_vdc_subblk_offset(c, SDE_VDC_CTL, &vdc_ctl_reg)) {
 		SDE_ERROR("vdc ctl not found\n");
 		kfree(c);
@@ -450,18 +438,12 @@ struct sde_hw_vdc *sde_hw_vdc_init(enum sde_vdc idx,
 			c->caps->sblk->ctl.len,
 			c->hw.xin_id);
 
-	return c;
-
-blk_init_error:
-	kfree(c);
-
-	return ERR_PTR(rc);
+	return &c->hw;
 }
 
-void sde_hw_vdc_destroy(struct sde_hw_vdc *vdc)
+void sde_hw_vdc_destroy(struct sde_hw_blk_reg_map *hw)
 {
-	if (vdc) {
-		sde_hw_blk_destroy(&vdc->base);
-		kfree(vdc);
+	if (hw) {
+		kfree(to_sde_hw_vdc(hw));
 	}
 }

msm/sde/sde_hw_vdc.h

@@ -1,6 +1,6 @@
 /* SPDX-License-Identifier: GPL-2.0-only */
 /*
- * Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2017-2021, The Linux Foundation. All rights reserved.
  */
 
 #ifndef _SDE_HW_VDC_H
@@ -9,7 +9,6 @@
 #include "sde_hw_catalog.h"
 #include "sde_hw_mdss.h"
 #include "sde_hw_util.h"
-#include "sde_hw_blk.h"
 
 struct sde_hw_vdc;
 struct msm_display_vdc_info;
@@ -46,7 +45,6 @@ struct sde_hw_vdc_ops {
 };
 
 struct sde_hw_vdc {
-	struct sde_hw_blk base;
 	struct sde_hw_blk_reg_map hw;
 
 	/* vdc */
@@ -58,13 +56,13 @@ struct sde_hw_vdc {
 };
 
 /**
- * sde_hw_vdc - convert base object sde_hw_base to container
- * @hw: Pointer to base hardware block
+ * to_sde_hw_vdc - convert base hw object to sde_hw_vdc container
+ * @hw: Pointer to hardware block register map object
  * return: Pointer to hardware block container
  */
-static inline struct sde_hw_vdc *to_sde_hw_vdc(struct sde_hw_blk *hw)
+static inline struct sde_hw_vdc *to_sde_hw_vdc(struct sde_hw_blk_reg_map *hw)
 {
-	return container_of(hw, struct sde_hw_vdc, base);
+	return container_of(hw, struct sde_hw_vdc, hw);
 }
 
 /**
@@ -75,15 +73,15 @@ static inline struct sde_hw_vdc *to_sde_hw_vdc(struct sde_hw_blk *hw)
  * @m:    Pointer to mdss catalog data
  * Returns: Error code or allocated sde_hw_vdc context
  */
-struct sde_hw_vdc *sde_hw_vdc_init(enum sde_vdc idx,
+struct sde_hw_blk_reg_map *sde_hw_vdc_init(enum sde_vdc idx,
 		void __iomem *addr,
 		struct sde_mdss_cfg *m);
 
 /**
  * sde_hw_vdc_destroy - destroys vdc driver context
  *                      should be called to free the context
- * @vdc:   Pointer to vdc driver context returned by sde_hw_vdc_init
+ * @hw:   Pointer to hardware block register map object
  */
-void sde_hw_vdc_destroy(struct sde_hw_vdc *vdc);
+void sde_hw_vdc_destroy(struct sde_hw_blk_reg_map *hw);
 
 #endif /*_SDE_HW_VDC_H */

msm/sde/sde_hw_wb.c

@@ -535,19 +535,13 @@ static void _setup_wb_ops(struct sde_hw_wb_ops *ops,
 		ops->program_cwb_dither_ctrl = sde_hw_wb_program_cwb_dither_ctrl;
 }
 
-static struct sde_hw_blk_ops sde_hw_ops = {
-	.start = NULL,
-	.stop = NULL,
-};
-
-struct sde_hw_wb *sde_hw_wb_init(enum sde_wb idx,
+struct sde_hw_blk_reg_map *sde_hw_wb_init(enum sde_wb idx,
 		void __iomem *addr,
 		struct sde_mdss_cfg *m,
 		struct sde_hw_mdp *hw_mdp)
 {
 	struct sde_hw_wb *c;
 	struct sde_wb_cfg *cfg;
-	int rc;
 
 	if (!addr || !m || !hw_mdp)
 		return ERR_PTR(-EINVAL);
@@ -571,12 +565,6 @@ struct sde_hw_wb *sde_hw_wb_init(enum sde_wb idx,
 	_setup_wb_ops(&c->ops, c->caps->features);
 	c->hw_mdp = hw_mdp;
 
-	rc = sde_hw_blk_init(&c->base, SDE_HW_BLK_WB, idx, &sde_hw_ops);
-	if (rc) {
-		SDE_ERROR("failed to init hw blk %d\n", rc);
-		goto blk_init_error;
-	}
-
 	sde_dbg_reg_register_dump_range(SDE_DBG_NAME, cfg->name, c->hw.blk_off,
 			c->hw.blk_off + c->hw.length, c->hw.xin_id);
 
@@ -588,17 +576,11 @@ struct sde_hw_wb *sde_hw_wb_init(enum sde_wb idx,
 		_sde_hw_dcwb_pp_ctrl_init(m, addr, c);
 	}
 
-	return c;
-
-blk_init_error:
-	kfree(c);
-
-	return ERR_PTR(rc);
+	return &c->hw;
 }
 
-void sde_hw_wb_destroy(struct sde_hw_wb *hw_wb)
+void sde_hw_wb_destroy(struct sde_hw_blk_reg_map *hw)
 {
-	if (hw_wb)
-		sde_hw_blk_destroy(&hw_wb->base);
-	kfree(hw_wb);
+	if (hw)
+		kfree(to_sde_hw_wb(hw));
 }

msm/sde/sde_hw_wb.h

@@ -178,7 +178,6 @@ struct sde_hw_wb_ops {
  * @dcwb_pp_hw: DCWB PingPong control hwio details
  */
 struct sde_hw_wb {
-	struct sde_hw_blk base;
 	struct sde_hw_blk_reg_map hw;
 	struct sde_mdss_cfg *catalog;
 	struct sde_mdp_cfg *mdp;
@@ -197,13 +196,13 @@ struct sde_hw_wb {
 };
 
 /**
- * sde_hw_wb - convert base object sde_hw_base to container
- * @hw: Pointer to base hardware block
+ * to_sde_hw_wb - convert base hw object to sde_hw_wb container
+ * @hw: Pointer to hardware block register map object
  * return: Pointer to hardware block container
  */
-static inline struct sde_hw_wb *to_sde_hw_wb(struct sde_hw_blk *hw)
+static inline struct sde_hw_wb *to_sde_hw_wb(struct sde_hw_blk_reg_map *hw)
 {
-	return container_of(hw, struct sde_hw_wb, base);
+	return container_of(hw, struct sde_hw_wb, hw);
 }
 
 /**
@@ -213,15 +212,15 @@ static inline struct sde_hw_wb *to_sde_hw_wb(struct sde_hw_blk *hw)
  * @m :   pointer to mdss catalog data
  * @hw_mdp: pointer to mdp top hw driver object
  */
-struct sde_hw_wb *sde_hw_wb_init(enum sde_wb idx,
+struct sde_hw_blk_reg_map *sde_hw_wb_init(enum sde_wb idx,
 		void __iomem *addr,
 		struct sde_mdss_cfg *m,
 		struct sde_hw_mdp *hw_mdp);
 
 /**
  * sde_hw_wb_destroy(): Destroy writeback hw driver object.
- * @hw_wb:  Pointer to writeback hw driver object
+ * @hw:  Pointer to hardware block register map object
  */
-void sde_hw_wb_destroy(struct sde_hw_wb *hw_wb);
+void sde_hw_wb_destroy(struct sde_hw_blk_reg_map *hw);
 
 #endif /*_SDE_HW_WB_H */

msm/sde/sde_rm.c

@@ -173,7 +173,7 @@ struct sde_rm_hw_blk {
 	struct sde_rm_rsvp *rsvp_nxt;
 	enum sde_hw_blk_type type;
 	uint32_t id;
-	struct sde_hw_blk *hw;
+	struct sde_hw_blk_reg_map *hw;
 };
 
 /**
@@ -471,7 +471,7 @@ static bool _sde_rm_request_hw_blk_locked(struct sde_rm *rm,
 			return false;
 		}
 
-		if (blk->hw->id == hw_blk_info->id) {
+		if (blk->id == hw_blk_info->id) {
 			hw_blk_info->hw = blk->hw;
 			SDE_DEBUG("found type %d id %d\n",
 					blk->type, blk->id);
@@ -507,7 +507,7 @@ bool sde_rm_request_hw_blk(struct sde_rm *rm, struct sde_rm_hw_request *hw)
 	return ret;
 }
 
-static void _sde_rm_hw_destroy(enum sde_hw_blk_type type, void *hw)
+static void _sde_rm_hw_destroy(enum sde_hw_blk_type type, struct sde_hw_blk_reg_map *hw)
 {
 	switch (type) {
 	case SDE_HW_BLK_LM:
@@ -599,7 +599,7 @@ static int _sde_rm_hw_blk_create(
 {
 	struct sde_rm_hw_blk *blk;
 	struct sde_hw_mdp *hw_mdp;
-	void *hw;
+	struct sde_hw_blk_reg_map *hw;
 
 	hw_mdp = rm->hw_mdp;
 
@@ -2710,45 +2710,3 @@ end:
 
 	return ret;
 }
-
-int sde_rm_ext_blk_destroy(struct sde_rm *rm,
-		struct drm_encoder *enc)
-{
-	struct sde_rm_hw_blk *blk = NULL, *p;
-	struct sde_rm_rsvp *rsvp;
-	enum sde_hw_blk_type type;
-	int ret = 0;
-
-	if (!rm || !enc) {
-		SDE_ERROR("invalid parameters\n");
-		return -EINVAL;
-	}
-
-	mutex_lock(&rm->rm_lock);
-
-	rsvp = _sde_rm_get_rsvp_cur(rm, enc);
-	if (!rsvp) {
-		ret = -ENOENT;
-		SDE_ERROR("failed to find rsvp for enc %d\n", enc->base.id);
-		goto end;
-	}
-
-	for (type = 0; type < SDE_HW_BLK_MAX; type++) {
-		list_for_each_entry_safe(blk, p, &rm->hw_blks[type], list) {
-			if (blk->rsvp == rsvp) {
-				list_del(&blk->list);
-				SDE_DEBUG("del blk %d %d from rsvp %d enc %d\n",
-						blk->type, blk->id,
-						rsvp->seq, rsvp->enc_id);
-				kfree(blk);
-			}
-		}
-	}
-
-	SDE_DEBUG("del rsvp %d\n", rsvp->seq);
-	list_del(&rsvp->list);
-	kfree(rsvp);
-end:
-	mutex_unlock(&rm->rm_lock);
-	return ret;
-}

msm/sde/sde_rm.h

@@ -196,7 +196,7 @@ struct sde_rm_hw_blk;
  * @type: Hardware Block Type client wishes to search for.
  */
 struct sde_rm_hw_iter {
-	void *hw;
+	struct sde_hw_blk_reg_map *hw;
 	struct sde_rm_hw_blk *blk;
 	uint32_t enc_id;
 	enum sde_hw_blk_type type;
@@ -209,7 +209,7 @@ struct sde_rm_hw_iter {
  * @id: Hardware block id
  */
 struct sde_rm_hw_request {
-	void *hw;
+	struct sde_hw_blk_reg_map *hw;
 	enum sde_hw_blk_type type;
 	int id;
 };
@@ -405,16 +405,6 @@ bool sde_rm_topology_is_group(struct sde_rm *rm,
 		struct drm_crtc_state *state,
 		enum sde_rm_topology_group group);
 
-/**
- * sde_rm_ext_blk_destroy - Given the encoder for the display chain, release
- *	external HW blocks created for that.
- * @rm: SDE Resource Manager handle
- * @enc: DRM Encoder handle
- * @Return: 0 on Success otherwise -ERROR
- */
-int sde_rm_ext_blk_destroy(struct sde_rm *rm,
-				struct drm_encoder *enc);
-
 /**
  * sde_rm_get_resource_info - returns avail hw resource info
  * @mr: sde rm object