diff --git a/drivers/gpu/nvgpu/include/bios.h b/drivers/gpu/nvgpu/include/bios.h
index 097e90ec9..bcb243439 100644
--- a/drivers/gpu/nvgpu/include/bios.h
+++ b/drivers/gpu/nvgpu/include/bios.h
@@ -1,7 +1,7 @@
 /*
  * vbios tables support
  *
- * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ * Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -510,7 +510,7 @@ struct pwr_sensors_2x_header {
 	u8 table_entry_size;
 	u8 num_table_entries;
 	u32 ba_script_pointer;
-};
+} __packed;
 
 #define VBIOS_POWER_SENSORS_2X_ENTRY_SIZE_15                          0x00000015
 
@@ -521,7 +521,7 @@ struct pwr_sensors_2x_entry {
 	u32 sensor_param1;
 	u32 sensor_param2;
 	u32 sensor_param3;
-};
+} __packed;
 
 #define NV_VBIOS_POWER_SENSORS_2X_ENTRY_FLAGS0_CLASS_MASK                   0xF
 #define NV_VBIOS_POWER_SENSORS_2X_ENTRY_FLAGS0_CLASS_SHIFT                    0
@@ -560,7 +560,7 @@ struct pwr_topology_2x_header {
 	u8 num_table_entries;
 	u8 rel_entry_size;
 	u8 num_rel_entries;
-};
+} __packed;
 
 #define VBIOS_POWER_TOPOLOGY_2X_ENTRY_SIZE_16                          0x00000016
 
@@ -572,7 +572,7 @@ struct pwr_topology_2x_entry {
 	u32 curr_corr_offset;
 	u32 param1;
 	u32 param2;
-};
+} __packed;
 
 #define NV_VBIOS_POWER_TOPOLOGY_2X_ENTRY_FLAGS0_CLASS_MASK                  0xF
 #define NV_VBIOS_POWER_TOPOLOGY_2X_ENTRY_FLAGS0_CLASS_SHIFT                   0
@@ -609,7 +609,7 @@ struct pwr_policy_3x_header_struct {
 	u8 sm_bus_policy_idx;
 	u8 table_viol_entry_size;
 	u8 num_table_viol_entries;
-};
+} __packed;
 
 #define VBIOS_POWER_POLICY_3X_ENTRY_SIZE_2E                           0x0000002E
 
@@ -631,7 +631,7 @@ struct pwr_policy_3x_entry_struct {
 	u16 ratio_max;
 	u8 sample_mult;
 	u32 filter_param;
-};
+} __packed;
 
 #define NV_VBIOS_POWER_POLICY_3X_ENTRY_FLAGS0_CLASS_MASK                    0xF
 #define NV_VBIOS_POWER_POLICY_3X_ENTRY_FLAGS0_CLASS_SHIFT                    0
diff --git a/drivers/gpu/nvgpu/pmgr/pwrpolicy.c b/drivers/gpu/nvgpu/pmgr/pwrpolicy.c
index cce3bd5ef..1e7e19a34 100644
--- a/drivers/gpu/nvgpu/pmgr/pwrpolicy.c
+++ b/drivers/gpu/nvgpu/pmgr/pwrpolicy.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
+ * Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -262,6 +262,11 @@ static struct boardobj *construct_pwr_policy(struct gk20a *g,
 	pwrpolicyhwthreshold = (struct pwr_policy_hw_threshold*)board_obj_ptr;
 	pwrpolicy = (struct pwr_policy *)board_obj_ptr;
 
+	gk20a_dbg_fn("min=%u rated=%u max=%u",
+		pwrpolicyparams->limit_min,
+		pwrpolicyparams->limit_rated,
+		pwrpolicyparams->limit_max);
+
 	/* Set Super class interfaces */
 	board_obj_ptr->pmudatainit = _pwr_domains_pmudatainit_hw_threshold;
 
@@ -351,53 +356,6 @@ static struct boardobj *construct_pwr_policy(struct gk20a *g,
 	return board_obj_ptr;
 }
 
-static u32 _pwr_policy_construct_WAR_policy(struct gk20a *g,
-			struct pmgr_pwr_policy *ppwrpolicyobjs,
-			union pwr_policy_data_union *ppwrpolicydata,
-			u16 pwr_policy_size,
-			u32 hw_threshold_policy_index,
-			u32 obj_index)
-{
-	u32 status = 0;
-	struct boardobj *boardobj;
-
-	if (!(hw_threshold_policy_index & 0x1)) {
-		/* CRIT policy */
-		ppwrpolicydata->pwrpolicy.limit_min = 1000;
-		ppwrpolicydata->pwrpolicy.limit_rated = 20000;
-		ppwrpolicydata->pwrpolicy.limit_max = 20000;
-		ppwrpolicydata->hw_threshold.threshold_idx = 0;
-	} else {
-		/* WARN policy */
-		ppwrpolicydata->pwrpolicy.limit_min = 1000;
-		ppwrpolicydata->pwrpolicy.limit_rated = 11600;
-		ppwrpolicydata->pwrpolicy.limit_max = 11600;
-		ppwrpolicydata->hw_threshold.threshold_idx = 1;
-	}
-
-	boardobj = construct_pwr_policy(g, ppwrpolicydata,
-				pwr_policy_size, ppwrpolicydata->boardobj.type);
-
-	if (!boardobj) {
-		gk20a_err(dev_from_gk20a(g),
-			"unable to create pwr policy for type %d", ppwrpolicydata->boardobj.type);
-		status = -EINVAL;
-		goto done;
-	}
-
-	status = boardobjgrp_objinsert(&ppwrpolicyobjs->pwr_policies.super,
-			boardobj, obj_index);
-
-	if (status) {
-		gk20a_err(dev_from_gk20a(g),
-			"unable to insert pwr policy boardobj for %d", obj_index);
-		status = -EINVAL;
-		goto done;
-	}
-done:
-	return status;
-}
-
 static u32 _pwr_policy_construct_WAR_SW_Threshold_policy(struct gk20a *g,
 			struct pmgr_pwr_policy *ppwrpolicyobjs,
 			union pwr_policy_data_union *ppwrpolicydata,
@@ -447,15 +405,114 @@ done:
 	return status;
 }
 
+struct pwr_policy_3x_header_unpacked {
+	u8 version;
+	u8 header_size;
+	u8 table_entry_size;
+	u8 num_table_entries;
+	u16 base_sample_period;
+	u16 min_client_sample_period;
+	u8 table_rel_entry_size;
+	u8 num_table_rel_entries;
+	u8 tgp_policy_idx;
+	u8 rtp_policy_idx;
+	u8 mxm_policy_idx;
+	u8 dnotifier_policy_idx;
+	u32 d2_limit;
+	u32 d3_limit;
+	u32 d4_limit;
+	u32 d5_limit;
+	u8 low_sampling_mult;
+	u8 pwr_tgt_policy_idx;
+	u8 pwr_tgt_floor_policy_idx;
+	u8 sm_bus_policy_idx;
+	u8 table_viol_entry_size;
+	u8 num_table_viol_entries;
+};
+
+#define __UNPACK_FIELD(unpacked, packed, field)	\
+	__builtin_memcpy(&unpacked->field, &packed->field, \
+		sizeof(unpacked->field))
+
+static inline void devinit_unpack_pwr_policy_header(
+	struct pwr_policy_3x_header_unpacked *unpacked,
+	struct pwr_policy_3x_header_struct *packed)
+{
+	__UNPACK_FIELD(unpacked, packed, version);
+	__UNPACK_FIELD(unpacked, packed, header_size);
+	__UNPACK_FIELD(unpacked, packed, table_entry_size);
+	__UNPACK_FIELD(unpacked, packed, num_table_entries);
+	__UNPACK_FIELD(unpacked, packed, base_sample_period);
+	__UNPACK_FIELD(unpacked, packed, min_client_sample_period);
+	__UNPACK_FIELD(unpacked, packed, table_rel_entry_size);
+	__UNPACK_FIELD(unpacked, packed, num_table_rel_entries);
+	__UNPACK_FIELD(unpacked, packed, tgp_policy_idx);
+	__UNPACK_FIELD(unpacked, packed, rtp_policy_idx);
+	__UNPACK_FIELD(unpacked, packed, mxm_policy_idx);
+	__UNPACK_FIELD(unpacked, packed, dnotifier_policy_idx);
+	__UNPACK_FIELD(unpacked, packed, d2_limit);
+	__UNPACK_FIELD(unpacked, packed, d3_limit);
+	__UNPACK_FIELD(unpacked, packed, d4_limit);
+	__UNPACK_FIELD(unpacked, packed, d5_limit);
+	__UNPACK_FIELD(unpacked, packed, low_sampling_mult);
+	__UNPACK_FIELD(unpacked, packed, pwr_tgt_policy_idx);
+	__UNPACK_FIELD(unpacked, packed, pwr_tgt_floor_policy_idx);
+	__UNPACK_FIELD(unpacked, packed, sm_bus_policy_idx);
+	__UNPACK_FIELD(unpacked, packed, table_viol_entry_size);
+	__UNPACK_FIELD(unpacked, packed, num_table_viol_entries);
+}
+
+struct pwr_policy_3x_entry_unpacked {
+	u8 flags0;
+	u8 ch_idx;
+	u32 limit_min;
+	u32 limit_rated;
+	u32 limit_max;
+	u32 param0;
+	u32 param1;
+	u32 param2;
+	u32 param3;
+	u32 limit_batt;
+	u8 flags1;
+	u8 past_length;
+	u8 next_length;
+	u16 ratio_min;
+	u16 ratio_max;
+	u8 sample_mult;
+	u32 filter_param;
+};
+
+static inline void devinit_unpack_pwr_policy_entry(
+	struct pwr_policy_3x_entry_unpacked *unpacked,
+	struct pwr_policy_3x_entry_struct *packed)
+{
+	__UNPACK_FIELD(unpacked, packed, flags0);
+	__UNPACK_FIELD(unpacked, packed, ch_idx);
+	__UNPACK_FIELD(unpacked, packed, limit_min);
+	__UNPACK_FIELD(unpacked, packed, limit_rated);
+	__UNPACK_FIELD(unpacked, packed, limit_max);
+	__UNPACK_FIELD(unpacked, packed, param0);
+	__UNPACK_FIELD(unpacked, packed, param1);
+	__UNPACK_FIELD(unpacked, packed, param2);
+	__UNPACK_FIELD(unpacked, packed, param3);
+	__UNPACK_FIELD(unpacked, packed, limit_batt);
+	__UNPACK_FIELD(unpacked, packed, flags1);
+	__UNPACK_FIELD(unpacked, packed, past_length);
+	__UNPACK_FIELD(unpacked, packed, next_length);
+	__UNPACK_FIELD(unpacked, packed, ratio_min);
+	__UNPACK_FIELD(unpacked, packed, ratio_max);
+	__UNPACK_FIELD(unpacked, packed, sample_mult);
+	__UNPACK_FIELD(unpacked, packed, filter_param);
+}
+
 static u32 devinit_get_pwr_policy_table(struct gk20a *g,
 			struct pmgr_pwr_policy *ppwrpolicyobjs)
 {
 	u32 status = 0;
-	u8 *pwr_policy_table_ptr = NULL;
-	u8 *curr_pwr_policy_table_ptr = NULL;
+	u8 *ptr = NULL;
 	struct boardobj *boardobj;
-	struct pwr_policy_3x_header_struct pwr_policy_table_header = { 0 };
-	struct pwr_policy_3x_entry_struct pwr_policy_table_entry = { 0 };
+	struct pwr_policy_3x_header_struct *packed_hdr;
+	struct pwr_policy_3x_header_unpacked hdr;
 	u32 index;
 	u32 obj_index = 0;
 	u16 pwr_policy_size;
@@ -469,162 +526,130 @@ static u32 devinit_get_pwr_policy_table(struct gk20a *g,
 	if (!g->ops.bios.get_perf_table_ptrs)
 		return -EINVAL;
 
-	pwr_policy_table_ptr = (u8 *)g->ops.bios.get_perf_table_ptrs(g,
+	ptr = (u8 *)g->ops.bios.get_perf_table_ptrs(g,
 			g->bios.perf_token, POWER_CAPPING_TABLE);
-	if (pwr_policy_table_ptr == NULL) {
+	if (ptr == NULL) {
 		status = -EINVAL;
 		goto done;
 	}
 
-	memcpy(&pwr_policy_table_header.version,
-		(pwr_policy_table_ptr),
-		14);
+	packed_hdr = (struct pwr_policy_3x_header_struct *)ptr;
 
-	memcpy(&pwr_policy_table_header.d2_limit,
-		(pwr_policy_table_ptr + 14),
-		(VBIOS_POWER_POLICY_3X_ENTRY_SIZE_2E - 14));
-
-	if (pwr_policy_table_header.version !=
+	if (packed_hdr->version !=
 			VBIOS_POWER_POLICY_VERSION_3X) {
 		status = -EINVAL;
 		goto done;
 	}
 
-	if (pwr_policy_table_header.header_size <
+	if (packed_hdr->header_size <
 			VBIOS_POWER_POLICY_3X_HEADER_SIZE_25) {
 		status = -EINVAL;
 		goto done;
 	}
 
-	if (pwr_policy_table_header.table_entry_size !=
+	if (packed_hdr->table_entry_size !=
 			VBIOS_POWER_POLICY_3X_ENTRY_SIZE_2E) {
 		status = -EINVAL;
 		goto done;
 	}
 
-	curr_pwr_policy_table_ptr = (pwr_policy_table_ptr +
-		VBIOS_POWER_POLICY_3X_HEADER_SIZE_25);
+	/* unpack power policy table header */
+	devinit_unpack_pwr_policy_header(&hdr, packed_hdr);
+
+	ptr += VBIOS_POWER_POLICY_3X_HEADER_SIZE_25;
+
+	for (index = 0; index < hdr.num_table_entries;
+		index++, ptr += (u32)hdr.table_entry_size) {
+
+		struct pwr_policy_3x_entry_struct *packed_entry;
+		struct pwr_policy_3x_entry_unpacked entry;
 
-	for (index = 0; index < pwr_policy_table_header.num_table_entries;
-		index++) {
 		u8 class_type;
 
-		curr_pwr_policy_table_ptr += (pwr_policy_table_header.table_entry_size * index);
-
-		pwr_policy_table_entry.flags0 = *curr_pwr_policy_table_ptr;
-		pwr_policy_table_entry.ch_idx = *(curr_pwr_policy_table_ptr + 1);
-
-		memcpy(&pwr_policy_table_entry.limit_min,
-			(curr_pwr_policy_table_ptr + 2),
-			35);
-
-		memcpy(&pwr_policy_table_entry.ratio_min,
-			(curr_pwr_policy_table_ptr + 2 + 35),
-			4);
-
-		pwr_policy_table_entry.sample_mult =
-				*(curr_pwr_policy_table_ptr + 2 + 35 + 4);
-
-		memcpy(&pwr_policy_table_entry.filter_param,
-			(curr_pwr_policy_table_ptr + 2 + 35 + 4 + 1),
-			4);
+		packed_entry = (struct pwr_policy_3x_entry_struct *)ptr;
 
 		class_type = (u8)BIOS_GET_FIELD(
-			pwr_policy_table_entry.flags0,
+			packed_entry->flags0,
 			NV_VBIOS_POWER_POLICY_3X_ENTRY_FLAGS0_CLASS);
 
-		if (class_type == NV_VBIOS_POWER_POLICY_3X_ENTRY_FLAGS0_CLASS_HW_THRESHOLD) {
-			ppwrpolicyobjs->version = CTRL_PMGR_PWR_POLICY_TABLE_VERSION_3X;
-			ppwrpolicyobjs->base_sample_period = (u16)
-					pwr_policy_table_header.base_sample_period;
-			ppwrpolicyobjs->min_client_sample_period = (u16)
-					pwr_policy_table_header.min_client_sample_period;
-			ppwrpolicyobjs->low_sampling_mult =
-					pwr_policy_table_header.low_sampling_mult;
-
-			ppwrpolicyobjs->policy_idxs[1] =
-				(u8)pwr_policy_table_header.tgp_policy_idx;
-			ppwrpolicyobjs->policy_idxs[0] =
-				(u8)pwr_policy_table_header.rtp_policy_idx;
-			ppwrpolicyobjs->policy_idxs[2] =
-				pwr_policy_table_header.mxm_policy_idx;
-			ppwrpolicyobjs->policy_idxs[3] =
-				pwr_policy_table_header.dnotifier_policy_idx;
-			ppwrpolicyobjs->ext_limits[0].limit =
-				pwr_policy_table_header.d2_limit;
-			ppwrpolicyobjs->ext_limits[1].limit =
-				pwr_policy_table_header.d3_limit;
-			ppwrpolicyobjs->ext_limits[2].limit =
-				pwr_policy_table_header.d4_limit;
-			ppwrpolicyobjs->ext_limits[3].limit =
-				pwr_policy_table_header.d5_limit;
-			ppwrpolicyobjs->policy_idxs[4] =
-				pwr_policy_table_header.pwr_tgt_policy_idx;
-			ppwrpolicyobjs->policy_idxs[5] =
-				pwr_policy_table_header.pwr_tgt_floor_policy_idx;
-			ppwrpolicyobjs->policy_idxs[6] =
-				pwr_policy_table_header.sm_bus_policy_idx;
-
-			integral_control = (bool)BIOS_GET_FIELD(
-				pwr_policy_table_entry.flags1,
-				NV_VBIOS_POWER_POLICY_3X_ENTRY_FLAGS1_INTEGRAL_CONTROL);
-
-			if (integral_control == 0x01) {
-				pwr_policy_data.pwrpolicy.integral.past_sample_count = (u8)
-						pwr_policy_table_entry.past_length;
-				pwr_policy_data.pwrpolicy.integral.next_sample_count = (u8)
-						pwr_policy_table_entry.next_length;
-				pwr_policy_data.pwrpolicy.integral.ratio_limit_max = (u16)
-						pwr_policy_table_entry.ratio_max;
-				pwr_policy_data.pwrpolicy.integral.ratio_limit_min = (u16)
-						pwr_policy_table_entry.ratio_min;
-			} else {
-				memset(&(pwr_policy_data.pwrpolicy.integral), 0x0,
-					sizeof(struct ctrl_pmgr_pwr_policy_info_integral));
-			}
-			pwr_policy_data.hw_threshold.threshold_idx = (u8)
-				BIOS_GET_FIELD(
-					pwr_policy_table_entry.param0,
-					NV_VBIOS_POWER_POLICY_3X_ENTRY_PARAM0_HW_THRESHOLD_THRES_IDX);
-
-			pwr_policy_data.hw_threshold.b_use_low_threshold =
-				BIOS_GET_FIELD(
-					pwr_policy_table_entry.param0,
-					NV_VBIOS_POWER_POLICY_3X_ENTRY_PARAM0_HW_THRESHOLD_LOW_THRESHOLD_USE);
-
-			if (pwr_policy_data.hw_threshold.b_use_low_threshold) {
-				pwr_policy_data.hw_threshold.low_threshold_idx = (u8)
-					BIOS_GET_FIELD(
-						pwr_policy_table_entry.param0,
-						NV_VBIOS_POWER_POLICY_3X_ENTRY_PARAM0_HW_THRESHOLD_LOW_THRESHOLD_IDX);
-
-				pwr_policy_data.hw_threshold.low_threshold_value = (u16)
-					BIOS_GET_FIELD(
-						pwr_policy_table_entry.param1,
-						NV_VBIOS_POWER_POLICY_3X_ENTRY_PARAM1_HW_THRESHOLD_LOW_THRESHOLD_VAL);
-			}
-
-			pwr_policy_size = sizeof(struct pwr_policy_hw_threshold);
-		} else
+		if (class_type != NV_VBIOS_POWER_POLICY_3X_ENTRY_FLAGS0_CLASS_HW_THRESHOLD)
 			continue;
 
+		/* unpack power policy table entry */
+		devinit_unpack_pwr_policy_entry(&entry, packed_entry);
+
+		ppwrpolicyobjs->version =
+				CTRL_PMGR_PWR_POLICY_TABLE_VERSION_3X;
+		ppwrpolicyobjs->base_sample_period = hdr.base_sample_period;
+		ppwrpolicyobjs->min_client_sample_period =
+				hdr.min_client_sample_period;
+		ppwrpolicyobjs->low_sampling_mult = hdr.low_sampling_mult;
+
+		ppwrpolicyobjs->policy_idxs[1] = hdr.tgp_policy_idx;
+		ppwrpolicyobjs->policy_idxs[0] = hdr.rtp_policy_idx;
+		ppwrpolicyobjs->policy_idxs[2] = hdr.mxm_policy_idx;
+		ppwrpolicyobjs->policy_idxs[3] = hdr.dnotifier_policy_idx;
+		ppwrpolicyobjs->ext_limits[0].limit = hdr.d2_limit;
+		ppwrpolicyobjs->ext_limits[1].limit = hdr.d3_limit;
+		ppwrpolicyobjs->ext_limits[2].limit = hdr.d4_limit;
+		ppwrpolicyobjs->ext_limits[3].limit = hdr.d5_limit;
+		ppwrpolicyobjs->policy_idxs[4] = hdr.pwr_tgt_policy_idx;
+		ppwrpolicyobjs->policy_idxs[5] = hdr.pwr_tgt_floor_policy_idx;
+		ppwrpolicyobjs->policy_idxs[6] = hdr.sm_bus_policy_idx;
+
+		integral_control = (bool)BIOS_GET_FIELD(entry.flags1,
+			NV_VBIOS_POWER_POLICY_3X_ENTRY_FLAGS1_INTEGRAL_CONTROL);
+
+		if (integral_control == 0x01) {
+			pwr_policy_data.pwrpolicy.integral.past_sample_count =
+					entry.past_length;
+			pwr_policy_data.pwrpolicy.integral.next_sample_count =
+					entry.next_length;
+			pwr_policy_data.pwrpolicy.integral.ratio_limit_max =
+					entry.ratio_max;
+			pwr_policy_data.pwrpolicy.integral.ratio_limit_min =
+					entry.ratio_min;
+		} else {
+			memset(&(pwr_policy_data.pwrpolicy.integral), 0x0,
+				sizeof(struct ctrl_pmgr_pwr_policy_info_integral));
+		}
+		pwr_policy_data.hw_threshold.threshold_idx = (u8)
+			BIOS_GET_FIELD(entry.param0,
+				NV_VBIOS_POWER_POLICY_3X_ENTRY_PARAM0_HW_THRESHOLD_THRES_IDX);
+
+		pwr_policy_data.hw_threshold.b_use_low_threshold =
+			BIOS_GET_FIELD(entry.param0,
+				NV_VBIOS_POWER_POLICY_3X_ENTRY_PARAM0_HW_THRESHOLD_LOW_THRESHOLD_USE);
+
+		if (pwr_policy_data.hw_threshold.b_use_low_threshold) {
+			pwr_policy_data.hw_threshold.low_threshold_idx = (u8)
+				BIOS_GET_FIELD(entry.param0,
+					NV_VBIOS_POWER_POLICY_3X_ENTRY_PARAM0_HW_THRESHOLD_LOW_THRESHOLD_IDX);
+
+			pwr_policy_data.hw_threshold.low_threshold_value = (u16)
+				BIOS_GET_FIELD(entry.param1,
+					NV_VBIOS_POWER_POLICY_3X_ENTRY_PARAM1_HW_THRESHOLD_LOW_THRESHOLD_VAL);
+		}
+
+		pwr_policy_size = sizeof(struct pwr_policy_hw_threshold);
+
 		/* Initialize data for the parent class */
-		pwr_policy_data.boardobj.type = CTRL_PMGR_PWR_POLICY_TYPE_HW_THRESHOLD;
-		pwr_policy_data.pwrpolicy.ch_idx = (u8)pwr_policy_table_entry.ch_idx;
+		pwr_policy_data.boardobj.type =
+				CTRL_PMGR_PWR_POLICY_TYPE_HW_THRESHOLD;
+		pwr_policy_data.pwrpolicy.ch_idx = entry.ch_idx;
 		pwr_policy_data.pwrpolicy.limit_unit = (u8)
-				BIOS_GET_FIELD(
-					pwr_policy_table_entry.flags0,
+				BIOS_GET_FIELD(entry.flags0,
 					NV_VBIOS_POWER_POLICY_3X_ENTRY_FLAGS0_LIMIT_UNIT);
 		pwr_policy_data.pwrpolicy.filter_type = (u8)
-				BIOS_GET_FIELD(
-					pwr_policy_table_entry.flags1,
+				BIOS_GET_FIELD(entry.flags1,
 					NV_VBIOS_POWER_POLICY_3X_ENTRY_FLAGS1_FILTER_TYPE);
-		pwr_policy_data.pwrpolicy.limit_min = pwr_policy_table_entry.limit_min;
-		pwr_policy_data.pwrpolicy.limit_rated = pwr_policy_table_entry.limit_rated;
-		pwr_policy_data.pwrpolicy.limit_max = pwr_policy_table_entry.limit_max;
-		pwr_policy_data.pwrpolicy.limit_batt = pwr_policy_table_entry.limit_batt;
 
-		pwr_policy_data.pwrpolicy.sample_mult  = (u8)pwr_policy_table_entry.sample_mult;
+		pwr_policy_data.pwrpolicy.limit_min = entry.limit_min;
+		pwr_policy_data.pwrpolicy.limit_rated = entry.limit_rated;
+		pwr_policy_data.pwrpolicy.limit_max = entry.limit_max;
+		pwr_policy_data.pwrpolicy.limit_batt = entry.limit_batt;
+
+		pwr_policy_data.pwrpolicy.sample_mult  = (u8)entry.sample_mult;
 
 		/* Filled the entry.filterParam value in the filterParam */
 		pwr_policy_data.pwrpolicy.filter_param.block.block_size = 0;
@@ -635,11 +660,12 @@ static u32 devinit_get_pwr_policy_table(struct gk20a *g,
 			BIT(pwr_policy_data.hw_threshold.threshold_idx);
 
 		boardobj = construct_pwr_policy(g, &pwr_policy_data,
-					pwr_policy_size, pwr_policy_data.boardobj.type);
+				pwr_policy_size, pwr_policy_data.boardobj.type);
 
 		if (!boardobj) {
 			gk20a_err(dev_from_gk20a(g),
-				"unable to create pwr policy for %d type %d", index, pwr_policy_data.boardobj.type);
+				"unable to create pwr policy for %d type %d",
+				index, pwr_policy_data.boardobj.type);
 			status = -EINVAL;
 			goto done;
 		}
@@ -649,7 +675,8 @@ static u32 devinit_get_pwr_policy_table(struct gk20a *g,
 
 		if (status) {
 			gk20a_err(dev_from_gk20a(g),
-				"unable to insert pwr policy boardobj for %d", index);
+				"unable to insert pwr policy boardobj for %d",
+				index);
 			status = -EINVAL;
 			goto done;
 		}
@@ -657,23 +684,6 @@ static u32 devinit_get_pwr_policy_table(struct gk20a *g,
 		++obj_index;
 	}
 
-	if (hw_threshold_policy_index &&
-		(hw_threshold_policy_index < 0x3)) {
-		status = _pwr_policy_construct_WAR_policy(g,
-					ppwrpolicyobjs,
-					&pwr_policy_data,
-					pwr_policy_size,
-					hw_threshold_policy_index,
-					obj_index);
-		if (status) {
-			gk20a_err(dev_from_gk20a(g),
-				"unable to construct_WAR_policy");
-			status = -EINVAL;
-			goto done;
-		}
-		++obj_index;
-	}
-
 	if (!sw_threshold_policy_index) {
 		status = _pwr_policy_construct_WAR_SW_Threshold_policy(g,
 					ppwrpolicyobjs,