diff --git a/msm/Kbuild b/msm/Kbuild
index 4f4ef472c7..50b7f029c7 100644
--- a/msm/Kbuild
+++ b/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 \
diff --git a/msm/sde/sde_crtc.c b/msm/sde/sde_crtc.c
index 68c354f182..0eb2845534 100644
--- a/msm/sde/sde_crtc.c
+++ b/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;
 
diff --git a/msm/sde/sde_encoder.c b/msm/sde/sde_encoder.c
index 9851421d25..981dffdeb3 100644
--- a/msm/sde/sde_encoder.c
+++ b/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);
 	}
 }
 
diff --git a/msm/sde/sde_encoder_phys_cmd.c b/msm/sde/sde_encoder_phys_cmd.c
index d48957508c..5460daca25 100644
--- a/msm/sde/sde_encoder_phys_cmd.c
+++ b/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)) {
diff --git a/msm/sde/sde_encoder_phys_vid.c b/msm/sde/sde_encoder_phys_vid.c
index f2d21db188..6b4339e1e4 100644
--- a/msm/sde/sde_encoder_phys_vid.c
+++ b/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)) {
diff --git a/msm/sde/sde_encoder_phys_wb.c b/msm/sde/sde_encoder_phys_wb.c
index 0f6d3e69d6..7acf52f14b 100644
--- a/msm/sde/sde_encoder_phys_wb.c
+++ b/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;
diff --git a/msm/sde/sde_hw_blk.c b/msm/sde/sde_hw_blk.c
deleted file mode 100644
index b97af12af2..0000000000
--- a/msm/sde/sde_hw_blk.c
+++ /dev/null
@@ -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);
-}
-
diff --git a/msm/sde/sde_hw_blk.h b/msm/sde/sde_hw_blk.h
deleted file mode 100644
index 27a08c585d..0000000000
--- a/msm/sde/sde_hw_blk.h
+++ /dev/null
@@ -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 */
diff --git a/msm/sde/sde_hw_cdm.c b/msm/sde/sde_hw_cdm.c
index 674b68e599..1ebeb92712 100644
--- a/msm/sde/sde_hw_cdm.c
+++ b/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));
 }
diff --git a/msm/sde/sde_hw_cdm.h b/msm/sde/sde_hw_cdm.h
index d49280baaa..6d30fe31ac 100644
--- a/msm/sde/sde_hw_cdm.h
+++ b/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 */
diff --git a/msm/sde/sde_hw_ctl.c b/msm/sde/sde_hw_ctl.c
index 56f2076ae6..33db91515d 100644
--- a/msm/sde/sde_hw_ctl.c
+++ b/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));
 }
diff --git a/msm/sde/sde_hw_ctl.h b/msm/sde/sde_hw_ctl.h
index 0d32400a9d..45b6749566 100644
--- a/msm/sde/sde_hw_ctl.h
+++ b/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 */
diff --git a/msm/sde/sde_hw_ds.c b/msm/sde/sde_hw_ds.c
index 8632ff6ec9..55ae3635ca 100644
--- a/msm/sde/sde_hw_ds.c
+++ b/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));
 }
diff --git a/msm/sde/sde_hw_ds.h b/msm/sde/sde_hw_ds.h
index 877f966480..01eb1f1ff8 100644
--- a/msm/sde/sde_hw_ds.h
+++ b/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 */
diff --git a/msm/sde/sde_hw_dsc.c b/msm/sde/sde_hw_dsc.c
index e10117c4d4..24fff905bb 100644
--- a/msm/sde/sde_hw_dsc.c
+++ b/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->hw;
 
-
-
-	return c;
-
-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));
 }
diff --git a/msm/sde/sde_hw_dsc.h b/msm/sde/sde_hw_dsc.h
index 33987c1465..615fd339aa 100644
--- a/msm/sde/sde_hw_dsc.h
+++ b/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 */
diff --git a/msm/sde/sde_hw_dspp.c b/msm/sde/sde_hw_dspp.c
index bf853008ff..a9dfd916ba 100644
--- a/msm/sde/sde_hw_dspp.c
+++ b/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);
 }
diff --git a/msm/sde/sde_hw_dspp.h b/msm/sde/sde_hw_dspp.h
index e30fe2577e..3d6c0ae625 100644
--- a/msm/sde/sde_hw_dspp.h
+++ b/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 */
diff --git a/msm/sde/sde_hw_intf.c b/msm/sde/sde_hw_intf.c
index baa0411b79..ffab1fab24 100644
--- a/msm/sde/sde_hw_intf.c
+++ b/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));
 }
 
diff --git a/msm/sde/sde_hw_intf.h b/msm/sde/sde_hw_intf.h
index 1619d1ffac..2da19bb46b 100644
--- a/msm/sde/sde_hw_intf.h
+++ b/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 */
diff --git a/msm/sde/sde_hw_lm.c b/msm/sde/sde_hw_lm.c
index 33308be9e0..c28f68c45c 100644
--- a/msm/sde/sde_hw_lm.c
+++ b/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));
 }
diff --git a/msm/sde/sde_hw_lm.h b/msm/sde/sde_hw_lm.h
index 931e318517..d399d54f34 100644
--- a/msm/sde/sde_hw_lm.h
+++ b/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 */
diff --git a/msm/sde/sde_hw_pingpong.c b/msm/sde/sde_hw_pingpong.c
index eb32acf83c..55218b6894 100644
--- a/msm/sde/sde_hw_pingpong.c
+++ b/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);
 	}
diff --git a/msm/sde/sde_hw_pingpong.h b/msm/sde/sde_hw_pingpong.h
index 74efd46d75..ca83172561 100644
--- a/msm/sde/sde_hw_pingpong.h
+++ b/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 */
diff --git a/msm/sde/sde_hw_qdss.c b/msm/sde/sde_hw_qdss.c
index 926db245db..7b888239b8 100644
--- a/msm/sde/sde_hw_qdss.c
+++ b/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));
 }
diff --git a/msm/sde/sde_hw_qdss.h b/msm/sde/sde_hw_qdss.h
index 00549dcbb1..82841c3180 100644
--- a/msm/sde/sde_hw_qdss.h
+++ b/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 */
diff --git a/msm/sde/sde_hw_sspp.c b/msm/sde/sde_hw_sspp.c
index a9e1e503e0..886dab5be2 100644
--- a/msm/sde/sde_hw_sspp.c
+++ b/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);
 	}
diff --git a/msm/sde/sde_hw_sspp.h b/msm/sde/sde_hw_sspp.h
index d7d1797668..750acbd9ce 100644
--- a/msm/sde/sde_hw_sspp.h
+++ b/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.
diff --git a/msm/sde/sde_hw_top.c b/msm/sde/sde_hw_top.c
index aca8494a54..372f439485 100644
--- a/msm/sde/sde_hw_top.c
+++ b/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);
 }
 
diff --git a/msm/sde/sde_hw_top.h b/msm/sde/sde_hw_top.h
index 745d64d214..57c2c25bde 100644
--- a/msm/sde/sde_hw_top.h
+++ b/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
diff --git a/msm/sde/sde_hw_vdc.c b/msm/sde/sde_hw_vdc.c
index 49dce86eb0..214c37403c 100644
--- a/msm/sde/sde_hw_vdc.c
+++ b/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));
 	}
 }
diff --git a/msm/sde/sde_hw_vdc.h b/msm/sde/sde_hw_vdc.h
index 1744eadbb1..7d9eb27cc5 100644
--- a/msm/sde/sde_hw_vdc.h
+++ b/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 */
diff --git a/msm/sde/sde_hw_wb.c b/msm/sde/sde_hw_wb.c
index ca5784a952..c980b71d95 100644
--- a/msm/sde/sde_hw_wb.c
+++ b/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));
 }
diff --git a/msm/sde/sde_hw_wb.h b/msm/sde/sde_hw_wb.h
index 0af60900ef..40bea8844a 100644
--- a/msm/sde/sde_hw_wb.h
+++ b/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 */
diff --git a/msm/sde/sde_rm.c b/msm/sde/sde_rm.c
index 31f633d847..e783441ff5 100644
--- a/msm/sde/sde_rm.c
+++ b/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;
-}
diff --git a/msm/sde/sde_rm.h b/msm/sde/sde_rm.h
index 4963fa1350..f2f6513ecb 100644
--- a/msm/sde/sde_rm.h
+++ b/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