diff --git a/userspace/snmpd/wrsNetworkingStatusGroup.c b/userspace/snmpd/wrsNetworkingStatusGroup.c
index 144f0457af84fd3f86b8f88b1e40b88133af630a..dc2b35918ad8be665104aad223ed3d8237eaff7f 100644
--- a/userspace/snmpd/wrsNetworkingStatusGroup.c
+++ b/userspace/snmpd/wrsNetworkingStatusGroup.c
@@ -21,26 +21,26 @@ static void copy_pstats(struct ns_pstats *copy, struct wrsPstatsHCTable_s *org,
 	int i;
 	for (i = 0; i < rows; i++) {
 		/* wrsEndpointStatus */
-		copy->TXUnderrun = org->TXUnderrun;
-		copy->RXOverrun = org->RXOverrun;
-		copy->RXInvalidCode = org->RXInvalidCode;
-		copy->RXSyncLost = org->RXSyncLost;
-		copy->RXPfilterDropped = org->RXPfilterDropped;
-		copy->RXPCSErrors = org->RXPCSErrors;
-		copy->RXCRCErrors = org->RXCRCErrors;
+		copy->wrsPstatsHCTXUnderrun = org->wrsPstatsHCTXUnderrun;
+		copy->wrsPstatsHCRXOverrun = org->wrsPstatsHCRXOverrun;
+		copy->wrsPstatsHCRXInvalidCode = org->wrsPstatsHCRXInvalidCode;
+		copy->wrsPstatsHCRXSyncLost = org->wrsPstatsHCRXSyncLost;
+		copy->wrsPstatsHCRXPfilterDropped = org->wrsPstatsHCRXPfilterDropped;
+		copy->wrsPstatsHCRXPCSErrors = org->wrsPstatsHCRXPCSErrors;
+		copy->wrsPstatsHCRXCRCErrors = org->wrsPstatsHCRXCRCErrors;
 		/* wrsSwcoreStatus */
-		copy->RXFrames = org->RXFrames;
-		copy->RXPrio0 = org->RXPrio0;
-		copy->RXPrio1 = org->RXPrio1;
-		copy->RXPrio2 = org->RXPrio2;
-		copy->RXPrio3 = org->RXPrio3;
-		copy->RXPrio4 = org->RXPrio4;
-		copy->RXPrio5 = org->RXPrio5;
-		copy->RXPrio6 = org->RXPrio6;
-		copy->RXPrio7 = org->RXPrio7;
-		copy->FastMatchPriority = org->FastMatchPriority;
+		copy->wrsPstatsHCRXFrames = org->wrsPstatsHCRXFrames;
+		copy->wrsPstatsHCRXPrio0 = org->wrsPstatsHCRXPrio0;
+		copy->wrsPstatsHCRXPrio1 = org->wrsPstatsHCRXPrio1;
+		copy->wrsPstatsHCRXPrio2 = org->wrsPstatsHCRXPrio2;
+		copy->wrsPstatsHCRXPrio3 = org->wrsPstatsHCRXPrio3;
+		copy->wrsPstatsHCRXPrio4 = org->wrsPstatsHCRXPrio4;
+		copy->wrsPstatsHCRXPrio5 = org->wrsPstatsHCRXPrio5;
+		copy->wrsPstatsHCRXPrio6 = org->wrsPstatsHCRXPrio6;
+		copy->wrsPstatsHCRXPrio7 = org->wrsPstatsHCRXPrio7;
+		copy->wrsPstatsHCFastMatchPriority = org->wrsPstatsHCFastMatchPriority;
 		/* wrsRTUStatus */
-		copy->RXDropRTUFull = org->RXDropRTUFull;
+		copy->wrsPstatsHCRXDropRTUFull = org->wrsPstatsHCRXDropRTUFull;
 
 		copy++;
 		org++;
@@ -61,13 +61,13 @@ static int get_endpoint_status(struct ns_pstats *old,
 	 * per second */
 	for (i = 0; i < rows; i++) {
 		if (
-		     ((new[i].TXUnderrun - old[i].TXUnderrun)/t_delta > 1.0)
-		     || ((new[i].RXOverrun - old[i].RXOverrun)/t_delta > 1.0)
-		     || ((new[i].RXInvalidCode - old[i].RXInvalidCode)/t_delta > 1.0)
-		     || ((new[i].RXSyncLost - old[i].RXSyncLost)/t_delta > 1.0)
-		     || ((new[i].RXPfilterDropped - old[i].RXPfilterDropped)/t_delta > 1.0)
-		     || ((new[i].RXPCSErrors - old[i].RXPCSErrors)/t_delta > 1.0)
-		     || ((new[i].RXCRCErrors - old[i].RXCRCErrors)/t_delta > 1.0)
+		     ((new[i].wrsPstatsHCTXUnderrun - old[i].wrsPstatsHCTXUnderrun)/t_delta > 1.0)
+		     || ((new[i].wrsPstatsHCRXOverrun - old[i].wrsPstatsHCRXOverrun)/t_delta > 1.0)
+		     || ((new[i].wrsPstatsHCRXInvalidCode - old[i].wrsPstatsHCRXInvalidCode)/t_delta > 1.0)
+		     || ((new[i].wrsPstatsHCRXSyncLost - old[i].wrsPstatsHCRXSyncLost)/t_delta > 1.0)
+		     || ((new[i].wrsPstatsHCRXPfilterDropped - old[i].wrsPstatsHCRXPfilterDropped)/t_delta > 1.0)
+		     || ((new[i].wrsPstatsHCRXPCSErrors - old[i].wrsPstatsHCRXPCSErrors)/t_delta > 1.0)
+		     || ((new[i].wrsPstatsHCRXCRCErrors - old[i].wrsPstatsHCRXCRCErrors)/t_delta > 1.0)
 		) {
 			/* if error, no need to check more, but do it just for
 			 * logs */
@@ -100,8 +100,8 @@ static int get_swcore_status(struct ns_pstats *old,
  * traffic!!! */
 #if 0
 		if ( /* shouldn't differ more than FORWARD_DELTA */
-		     ((new[i].TXFrames - new[i].Forwarded) > FORWARD_DELTA)
-		     || ((new[i].Forwarded - new[i].TXFrames) > FORWARD_DELTA)
+		     ((new[i].wrsPstatsHCTXFrames - new[i].wrsPstatsHCForwarded) > FORWARD_DELTA)
+		     || ((new[i].wrsPstatsHCForwarded - new[i].wrsPstatsHCTXFrames) > FORWARD_DELTA)
 		) {
 			/* if error, no need to check more, but do it just for
 			 * logs */
@@ -114,16 +114,16 @@ static int get_swcore_status(struct ns_pstats *old,
 		 * full" in wrs_failures document shouldn't change faster
 		 * than parameters defined in dotconfig per second */
 		if ( /* shouldn't differ more than FORWARD_DELTA */
-		     ((new[i].RXFrames - old[i].RXFrames)/t_delta >= ns_dotconfig.rx_frame_rate)
-		     || ((new[i].RXPrio0 - old[i].RXPrio0)/t_delta >= ns_dotconfig.rx_prio_frame_rate)
-		     || ((new[i].RXPrio1 - old[i].RXPrio1)/t_delta >= ns_dotconfig.rx_prio_frame_rate)
-		     || ((new[i].RXPrio2 - old[i].RXPrio2)/t_delta >= ns_dotconfig.rx_prio_frame_rate)
-		     || ((new[i].RXPrio3 - old[i].RXPrio3)/t_delta >= ns_dotconfig.rx_prio_frame_rate)
-		     || ((new[i].RXPrio4 - old[i].RXPrio4)/t_delta >= ns_dotconfig.rx_prio_frame_rate)
-		     || ((new[i].RXPrio5 - old[i].RXPrio5)/t_delta >= ns_dotconfig.rx_prio_frame_rate)
-		     || ((new[i].RXPrio6 - old[i].RXPrio6)/t_delta >= ns_dotconfig.rx_prio_frame_rate)
-		     || ((new[i].RXPrio7 - old[i].RXPrio7)/t_delta >= ns_dotconfig.rx_prio_frame_rate)
-		     || ((new[i].FastMatchPriority - old[i].FastMatchPriority)/t_delta >= ns_dotconfig.hp_frame_rate)
+		     ((new[i].wrsPstatsHCRXFrames - old[i].wrsPstatsHCRXFrames)/t_delta >= ns_dotconfig.rx_frame_rate)
+		     || ((new[i].wrsPstatsHCRXPrio0 - old[i].wrsPstatsHCRXPrio0)/t_delta >= ns_dotconfig.rx_prio_frame_rate)
+		     || ((new[i].wrsPstatsHCRXPrio1 - old[i].wrsPstatsHCRXPrio1)/t_delta >= ns_dotconfig.rx_prio_frame_rate)
+		     || ((new[i].wrsPstatsHCRXPrio2 - old[i].wrsPstatsHCRXPrio2)/t_delta >= ns_dotconfig.rx_prio_frame_rate)
+		     || ((new[i].wrsPstatsHCRXPrio3 - old[i].wrsPstatsHCRXPrio3)/t_delta >= ns_dotconfig.rx_prio_frame_rate)
+		     || ((new[i].wrsPstatsHCRXPrio4 - old[i].wrsPstatsHCRXPrio4)/t_delta >= ns_dotconfig.rx_prio_frame_rate)
+		     || ((new[i].wrsPstatsHCRXPrio5 - old[i].wrsPstatsHCRXPrio5)/t_delta >= ns_dotconfig.rx_prio_frame_rate)
+		     || ((new[i].wrsPstatsHCRXPrio6 - old[i].wrsPstatsHCRXPrio6)/t_delta >= ns_dotconfig.rx_prio_frame_rate)
+		     || ((new[i].wrsPstatsHCRXPrio7 - old[i].wrsPstatsHCRXPrio7)/t_delta >= ns_dotconfig.rx_prio_frame_rate)
+		     || ((new[i].wrsPstatsHCFastMatchPriority - old[i].wrsPstatsHCFastMatchPriority)/t_delta >= ns_dotconfig.hp_frame_rate)
 		) {
 			/* if error, no need to check more, but do it just for
 			 * logs */
@@ -146,7 +146,7 @@ static int get_rtu_status(struct ns_pstats *old,
 	/* values from 2.2.4 "RTU is full and cannot accept more requests" in
 	 * wrs_failures document shouldn't increase */
 	for (i = 0; i < rows; i++) {
-		if ((new[i].RXDropRTUFull - old[i].RXDropRTUFull) > 0) {
+		if ((new[i].wrsPstatsHCRXDropRTUFull - old[i].wrsPstatsHCRXDropRTUFull) > 0) {
 			/* if error, no need to check more, but do it just for
 			 * logs */
 			ret = 1;
@@ -225,16 +225,16 @@ time_t wrsNetworkingStatus_data_fill(void)
 	port_status_n_na = 0;
 	/* count number of ports of each status */
 	for (i = 0; i < port_status_nrows; i++) {
-		if (p_a[i].sfp_error == WRS_PORT_STATUS_SFP_ERROR_SFP_OK) {
+		if (p_a[i].wrsPortStatusSfpError == WRS_PORT_STATUS_SFP_ERROR_SFP_OK) {
 			port_status_n_ok++;
 		}
-		if (p_a[i].sfp_error == WRS_PORT_STATUS_SFP_ERROR_SFP_ERROR) {
+		if (p_a[i].wrsPortStatusSfpError == WRS_PORT_STATUS_SFP_ERROR_SFP_ERROR) {
 			port_status_n_error++;
 		}
-		if (p_a[i].sfp_error == WRS_PORT_STATUS_SFP_ERROR_PORT_DOWN) {
+		if (p_a[i].wrsPortStatusSfpError == WRS_PORT_STATUS_SFP_ERROR_PORT_DOWN) {
 			port_status_n_down++;
 		}
-		if (p_a[i].sfp_error == 0) {
+		if (p_a[i].wrsPortStatusSfpError == 0) {
 			port_status_n_na++;
 		}
 	}
diff --git a/userspace/snmpd/wrsNetworkingStatusGroup.h b/userspace/snmpd/wrsNetworkingStatusGroup.h
index 62c41dd6c1692a34672d8eb590eebdb686fec551..fd9d999778ce5d50b2fb7d2afb944128e5971f3f 100644
--- a/userspace/snmpd/wrsNetworkingStatusGroup.h
+++ b/userspace/snmpd/wrsNetworkingStatusGroup.h
@@ -38,27 +38,27 @@ void init_wrsNetworkingStatusGroup(void);
 
 struct ns_pstats {
 	/* wrsEndpointStatus */
-	uint64_t TXUnderrun;		/* 1 */
-	uint64_t RXOverrun;		/* 2 */
-	uint64_t RXInvalidCode;		/* 3 */
-	uint64_t RXSyncLost;		/* 4 */
-	uint64_t RXPfilterDropped;	/* 6 */
-	uint64_t RXPCSErrors;		/* 7 */
-	uint64_t RXCRCErrors;		/* 10 */
+	uint64_t wrsPstatsHCTXUnderrun;		/* 1 */
+	uint64_t wrsPstatsHCRXOverrun;		/* 2 */
+	uint64_t wrsPstatsHCRXInvalidCode;	/* 3 */
+	uint64_t wrsPstatsHCRXSyncLost;		/* 4 */
+	uint64_t wrsPstatsHCRXPfilterDropped;	/* 6 */
+	uint64_t wrsPstatsHCRXPCSErrors;	/* 7 */
+	uint64_t wrsPstatsHCRXCRCErrors;	/* 10 */
 	/* wrsSwcoreStatus */
 	/* Too much HP traffic / Per-priority queue full */
-	uint64_t RXFrames;		/* 20 */
-	uint64_t RXPrio0;		/* 22 */
-	uint64_t RXPrio1;		/* 23 */
-	uint64_t RXPrio2;		/* 24 */
-	uint64_t RXPrio3;		/* 25 */
-	uint64_t RXPrio4;		/* 26 */
-	uint64_t RXPrio5;		/* 27 */
-	uint64_t RXPrio6;		/* 28 */
-	uint64_t RXPrio7;		/* 29 */
-	uint64_t FastMatchPriority;	/* 33 */
+	uint64_t wrsPstatsHCRXFrames;		/* 20 */
+	uint64_t wrsPstatsHCRXPrio0;		/* 22 */
+	uint64_t wrsPstatsHCRXPrio1;		/* 23 */
+	uint64_t wrsPstatsHCRXPrio2;		/* 24 */
+	uint64_t wrsPstatsHCRXPrio3;		/* 25 */
+	uint64_t wrsPstatsHCRXPrio4;		/* 26 */
+	uint64_t wrsPstatsHCRXPrio5;		/* 27 */
+	uint64_t wrsPstatsHCRXPrio6;		/* 28 */
+	uint64_t wrsPstatsHCRXPrio7;		/* 29 */
+	uint64_t wrsPstatsHCFastMatchPriority;	/* 33 */
 	/* wrsRTUStatus */
-	uint64_t RXDropRTUFull;		/* 21 */
+	uint64_t wrsPstatsHCRXDropRTUFull;	/* 21 */
 };
 
 /* parameters read from dot-config */
diff --git a/userspace/snmpd/wrsOSStatusGroup.c b/userspace/snmpd/wrsOSStatusGroup.c
index 1ec13ea5e957308fbbb524fd34fa0e5a99a88e9d..a566b16dd9b3f12a54e4b880ec7b3759a986f3cb 100644
--- a/userspace/snmpd/wrsOSStatusGroup.c
+++ b/userspace/snmpd/wrsOSStatusGroup.c
@@ -149,10 +149,10 @@ time_t wrsOSStatus_data_fill(void)
 	/*********************************************************************\
 	|*********************** wrsTemperatureWarning ***********************|
 	\*********************************************************************/
-	if (!wrsTemperature_s.temp_fpga_thold
-	    && !wrsTemperature_s.temp_pll_thold
-	    && !wrsTemperature_s.temp_psl_thold
-	    && !wrsTemperature_s.temp_psr_thold) {
+	if (!wrsTemperature_s.wrsTempThresholdFPGA
+	    && !wrsTemperature_s.wrsTempThresholdPLL
+	    && !wrsTemperature_s.wrsTempThresholdPSL
+	    && !wrsTemperature_s.wrsTempThresholdPSR) {
 		/* no threshold are set */
 		wrsOSStatus_s.wrsTemperatureWarning =
 					WRS_TEMPERATURE_WARNING_THOLD_NOT_SET;
@@ -163,10 +163,10 @@ time_t wrsOSStatus_data_fill(void)
 		  * 2 is ok (WRS_TEMPERATURE_WARNING_OK), 3 is temperature too
 		  * high (WRS_TEMPERATURE_WARNING_TOO_HIGH) */
 		wrsOSStatus_s.wrsTemperatureWarning = 2 +
-		    ((wrsTemperature_s.temp_fpga > wrsTemperature_s.temp_fpga_thold)
-		    || (wrsTemperature_s.temp_pll > wrsTemperature_s.temp_pll_thold)
-		    || (wrsTemperature_s.temp_psl > wrsTemperature_s.temp_psl_thold)
-		    || (wrsTemperature_s.temp_psr > wrsTemperature_s.temp_psr_thold));
+		    ((wrsTemperature_s.wrsTempFPGA > wrsTemperature_s.wrsTempThresholdFPGA)
+		    || (wrsTemperature_s.wrsTempPLL > wrsTemperature_s.wrsTempThresholdPLL)
+		    || (wrsTemperature_s.wrsTempPSL > wrsTemperature_s.wrsTempThresholdPSL)
+		    || (wrsTemperature_s.wrsTempPSR > wrsTemperature_s.wrsTempThresholdPSR));
 	}
 
 	/*********************************************************************\
diff --git a/userspace/snmpd/wrsPortStatusTable.c b/userspace/snmpd/wrsPortStatusTable.c
index bed9900958822898ac48566443abede5092c33d6..a4ce48d18f81695158119c78b45d0e23a3aea1e3 100644
--- a/userspace/snmpd/wrsPortStatusTable.c
+++ b/userspace/snmpd/wrsPortStatusTable.c
@@ -7,19 +7,19 @@ struct wrsPortStatusTable_s wrsPortStatusTable_array[WRS_N_PORTS];
 
 static struct pickinfo wrsPortStatusTable_pickinfo[] = {
 	FIELD(wrsPortStatusTable_s, ASN_UNSIGNED, index), /* not reported */
-	FIELD(wrsPortStatusTable_s, ASN_OCTET_STR, port_name),
-	FIELD(wrsPortStatusTable_s, ASN_INTEGER, link_up),
-	FIELD(wrsPortStatusTable_s, ASN_INTEGER, port_mode),
-	FIELD(wrsPortStatusTable_s, ASN_INTEGER, port_locked),
-	FIELD(wrsPortStatusTable_s, ASN_OCTET_STR, peer_id),
-	FIELD(wrsPortStatusTable_s, ASN_OCTET_STR, sfp_vn),
-	FIELD(wrsPortStatusTable_s, ASN_OCTET_STR, sfp_pn),
-	FIELD(wrsPortStatusTable_s, ASN_OCTET_STR, sfp_vs),
-	FIELD(wrsPortStatusTable_s, ASN_INTEGER, sfp_in_db),
-	FIELD(wrsPortStatusTable_s, ASN_INTEGER, sfp_GbE),
-	FIELD(wrsPortStatusTable_s, ASN_INTEGER, sfp_error),
-	FIELD(wrsPortStatusTable_s, ASN_COUNTER, ptp_tx_count),
-	FIELD(wrsPortStatusTable_s, ASN_COUNTER, ptp_rx_count),
+	FIELD(wrsPortStatusTable_s, ASN_OCTET_STR, wrsPortStatusPortName),
+	FIELD(wrsPortStatusTable_s, ASN_INTEGER, wrsPortStatusLink),
+	FIELD(wrsPortStatusTable_s, ASN_INTEGER, wrsPortStatusConfiguredMode),
+	FIELD(wrsPortStatusTable_s, ASN_INTEGER, wrsPortStatusLocked),
+	FIELD(wrsPortStatusTable_s, ASN_OCTET_STR, wrsPortStatusPeer),
+	FIELD(wrsPortStatusTable_s, ASN_OCTET_STR, wrsPortStatusSfpVN),
+	FIELD(wrsPortStatusTable_s, ASN_OCTET_STR, wrsPortStatusSfpPN),
+	FIELD(wrsPortStatusTable_s, ASN_OCTET_STR, wrsPortStatusSfpVS),
+	FIELD(wrsPortStatusTable_s, ASN_INTEGER, wrsPortStatusSfpInDB),
+	FIELD(wrsPortStatusTable_s, ASN_INTEGER, wrsPortStatusSfpGbE),
+	FIELD(wrsPortStatusTable_s, ASN_INTEGER, wrsPortStatusSfpError),
+	FIELD(wrsPortStatusTable_s, ASN_COUNTER, wrsPortStatusPtpTxFrames),
+	FIELD(wrsPortStatusTable_s, ASN_COUNTER, wrsPortStatusPtpRxFrames),
 };
 
 
@@ -66,11 +66,11 @@ time_t wrsPortStatusTable_data_fill(unsigned int *n_rows)
 		for (i = 0; i < hal_nports_local; ++i) {
 			/* Assume that number of ports does not change between
 			 * reads */
-			snprintf(wrsPortStatusTable_array[i].port_name, 10,
+			snprintf(wrsPortStatusTable_array[i].wrsPortStatusPortName, 10,
 				 "wri%d", i + 1);
 			port_state = hal_lookup_port(hal_ports,
 					hal_nports_local,
-					wrsPortStatusTable_array[i].port_name);
+					wrsPortStatusTable_array[i].wrsPortStatusPortName);
 			if(!port_state) {
 				/* It looks like we're in strange situation
 				 * that HAL is up but hal_ports is not filled
@@ -82,38 +82,38 @@ time_t wrsPortStatusTable_data_fill(unsigned int *n_rows)
 			 * Keep value 0 for Not available
 			 * values defined as WRS_PORT_STATUS_LINK_*
 			*/
-			wrsPortStatusTable_array[i].link_up =
+			wrsPortStatusTable_array[i].wrsPortStatusLink =
 					1 + state_up(port_state->state);
 			 /* values defined as
 			  * WRS_PORT_STATUS_CONFIGURED_MODE_* */
-			wrsPortStatusTable_array[i].port_mode =
+			wrsPortStatusTable_array[i].wrsPortStatusConfiguredMode =
 							port_state->mode;
 			if (port_state->state == HAL_PORT_STATE_DISABLED) {
-				wrsPortStatusTable_array[i].sfp_error =
+				wrsPortStatusTable_array[i].wrsPortStatusSfpError =
 					  WRS_PORT_STATUS_SFP_ERROR_PORT_DOWN;
 				/* if port is disabled don't fill
 				 * other fields */
 				continue;
 			}
 			/* Keep value 0 for Not available */
-			wrsPortStatusTable_array[i].port_locked =
+			wrsPortStatusTable_array[i].wrsPortStatusLocked =
 							1 + port_state->locked;
 			/* FIXME: get real peer_id */
-			memset(&wrsPortStatusTable_array[i].peer_id, 0xff,
+			memset(&wrsPortStatusTable_array[i].wrsPortStatusPeer, 0xff,
 			       sizeof(ClockIdentity));
-			wrsPortStatusTable_array[i].sfp_in_db =
+			wrsPortStatusTable_array[i].wrsPortStatusSfpInDB =
 			  port_state->calib.sfp.flags & SFP_FLAG_IN_DB ? 2 : 1;
-			wrsPortStatusTable_array[i].sfp_GbE =
+			wrsPortStatusTable_array[i].wrsPortStatusSfpGbE =
 			  port_state->calib.sfp.flags & SFP_FLAG_1GbE ? 2 : 1;
-			strncpy(wrsPortStatusTable_array[i].sfp_vn,
+			strncpy(wrsPortStatusTable_array[i].wrsPortStatusSfpVN,
 				port_state->calib.sfp.vendor_name,
-				sizeof(wrsPortStatusTable_array[i].sfp_vn));
-			strncpy(wrsPortStatusTable_array[i].sfp_pn,
+				sizeof(wrsPortStatusTable_array[i].wrsPortStatusSfpVN));
+			strncpy(wrsPortStatusTable_array[i].wrsPortStatusSfpPN,
 				port_state->calib.sfp.part_num,
-				sizeof(wrsPortStatusTable_array[i].sfp_pn));
-			strncpy(wrsPortStatusTable_array[i].sfp_vs,
+				sizeof(wrsPortStatusTable_array[i].wrsPortStatusSfpPN));
+			strncpy(wrsPortStatusTable_array[i].wrsPortStatusSfpVS,
 				port_state->calib.sfp.vendor_serial,
-				sizeof(wrsPortStatusTable_array[i].sfp_vs));
+				sizeof(wrsPortStatusTable_array[i].wrsPortStatusSfpVS));
 			/* sfp error when SFP is not 1 GbE or
 			 * (port is not wr-non mode and sfp not in data base)
 			 * Keep value 0 for Not available 
@@ -121,16 +121,16 @@ time_t wrsPortStatusTable_data_fill(unsigned int *n_rows)
 			 * sfp error is 2 WRS_PORT_STATUS_SFP_ERROR_SFP_ERROR
 			 * port down, set above, is 3
 			 * (WRS_PORT_STATUS_SFP_ERROR_PORT_DOWN) */
-			wrsPortStatusTable_array[i].sfp_error = 1 +
-				((wrsPortStatusTable_array[i].sfp_GbE == 1) ||
+			wrsPortStatusTable_array[i].wrsPortStatusSfpError = 1 +
+				((wrsPortStatusTable_array[i].wrsPortStatusSfpGbE == 1) ||
 				((port_state->mode != HEXP_PORT_MODE_NON_WR) &&
-				(wrsPortStatusTable_array[i].sfp_in_db == 1)));
+				(wrsPortStatusTable_array[i].wrsPortStatusSfpInDB == 1)));
 
 			snmp_log(LOG_DEBUG, "reading ports name %s link %d, "
 				"mode %d, locked %d\n", port_state->name,
-				wrsPortStatusTable_array[i].link_up,
-				wrsPortStatusTable_array[i].port_mode,
-				wrsPortStatusTable_array[i].port_locked);
+				wrsPortStatusTable_array[i].wrsPortStatusLink,
+				wrsPortStatusTable_array[i].wrsPortStatusConfiguredMode,
+				wrsPortStatusTable_array[i].wrsPortStatusLocked);
 		}
 
 		retries++;
@@ -153,15 +153,15 @@ time_t wrsPortStatusTable_data_fill(unsigned int *n_rows)
 		return time_cur;
 	}
 
-	/* fill ptp_tx_count and ptp_tx_count
-	 * ptp_tx_count and ptp_tx_count statistics in PPSI are collected per
+	/* fill wrsPortStatusPtpTxFrames and wrsPortStatusPtpRxFrames
+	 * ptp_tx_count and ptp_rx_count statistics in PPSI are collected per
 	 * ppi instance. Since there can be more than one instance per physical
 	 * port, proper counters has to be added. */
 	while (1) {
 		ii = wrs_shm_seqbegin(ppsi_head);
 		/* Match port name with interface name of ppsi instance.
 		 * More than one ppsi_iface_name can match to
-		 * wrsPortStatusTable_array[i].port_name, but only one can
+		 * wrsPortStatusTable_array[i].wrsPortStatusPortName, but only one can
 		 * match way round */
 		for (ppi_i = 0; ppi_i < *ppsi_ppi_nlinks; ppi_i++) {
 			/* (ppsi_ppi + ppi_i)->iface_name is a pointer in
@@ -172,11 +172,11 @@ time_t wrsPortStatusTable_data_fill(unsigned int *n_rows)
 			ppsi_iface_name = (char *) wrs_shm_follow(ppsi_head,
 					       (ppsi_ppi + ppi_i)->iface_name);
 			for (i = 0; i < hal_nports_local; ++i) {
-				if (!strncmp(wrsPortStatusTable_array[i].port_name,
+				if (!strncmp(wrsPortStatusTable_array[i].wrsPortStatusPortName,
 					     ppsi_iface_name, 12)) {
-					wrsPortStatusTable_array[i].ptp_tx_count +=
+					wrsPortStatusTable_array[i].wrsPortStatusPtpTxFrames +=
 					      (ppsi_ppi + ppi_i)->ptp_tx_count;
-					wrsPortStatusTable_array[i].ptp_rx_count +=
+					wrsPortStatusTable_array[i].wrsPortStatusPtpRxFrames +=
 					      (ppsi_ppi + ppi_i)->ptp_rx_count;
 					/* speed up a little, break here */
 					break;
diff --git a/userspace/snmpd/wrsPortStatusTable.h b/userspace/snmpd/wrsPortStatusTable.h
index da0580dba2133d9f7a8f2596be56a3c8dadb22ef..8d90bbd02b544894bf16e7e4ef4577e19147bfd1 100644
--- a/userspace/snmpd/wrsPortStatusTable.h
+++ b/userspace/snmpd/wrsPortStatusTable.h
@@ -20,20 +20,20 @@
 struct wrsPortStatusTable_s {
 	uint32_t index;		/* not reported, index fields has to be marked
 				 * as not-accessible in MIB */
-	char port_name[12];	/* port name */
-	ClockIdentity peer_id;
+	char wrsPortStatusPortName[12];	/* port name */
+	ClockIdentity wrsPortStatusPeer;
 	/* These can't be "unsigned char" because we scanf a %i in there */
-	unsigned link_up;
-	unsigned port_mode;
-	unsigned port_locked;
-	char sfp_vn[16];	/* vendor name */
-	char sfp_pn[16];	/* part name */
-	char sfp_vs[16];	/* vendor serial */
-	int sfp_in_db;
-	int sfp_GbE;
-	int sfp_error;
-	unsigned long ptp_tx_count;
-	unsigned long ptp_rx_count;
+	unsigned wrsPortStatusLink;
+	unsigned wrsPortStatusConfiguredMode;
+	unsigned wrsPortStatusLocked;
+	char wrsPortStatusSfpVN[16];	/* vendor name */
+	char wrsPortStatusSfpPN[16];	/* part name */
+	char wrsPortStatusSfpVS[16];	/* vendor serial */
+	int wrsPortStatusSfpInDB;
+	int wrsPortStatusSfpGbE;
+	int wrsPortStatusSfpError;
+	unsigned long wrsPortStatusPtpTxFrames;
+	unsigned long wrsPortStatusPtpRxFrames;
 };
 
 
diff --git a/userspace/snmpd/wrsPstatsHCTable.c b/userspace/snmpd/wrsPstatsHCTable.c
index 244ad42c4ec84ee27925d8d2211a0dfab5b48eb1..de2119820dc9ae0d01db3a5d12b9f69af7ee2fcc 100644
--- a/userspace/snmpd/wrsPstatsHCTable.c
+++ b/userspace/snmpd/wrsPstatsHCTable.c
@@ -5,47 +5,47 @@ struct wrsPstatsHCTable_s pstats_array[WRS_N_PORTS];
 
 static struct pickinfo wrsPstatsHCTable_pickinfo[] = {
 	/* Warning: strings are a special case for snmp format */
-	FIELD(wrsPstatsHCTable_s, ASN_UNSIGNED, index), /* not reported */
-	FIELD(wrsPstatsHCTable_s, ASN_OCTET_STR, port_name),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, TXUnderrun),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RXOverrun),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RXInvalidCode),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RXSyncLost),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RXPauseFrames),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RXPfilterDropped),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RXPCSErrors),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RXGiantFrames),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RXRuntFrames),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RXCRCErrors),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RXPclass0),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RXPclass1),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RXPclass2),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RXPclass3),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RXPclass4),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RXPclass5),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RXPclass6),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RXPclass7),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, TXFrames),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RXFrames),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RXDropRTUFull),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RXPrio0),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RXPrio1),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RXPrio2),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RXPrio3),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RXPrio4),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RXPrio5),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RXPrio6),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RXPrio7),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RTUValid),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RTUResponses),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, RTUDropped),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, FastMatchPriority),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, FastMatchFastForward),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, FastMatchNonForward),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, FastMatchRespValid),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, FullMatchRespValid),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, Forwarded),
-	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, TRURespValid),
+	FIELD(wrsPstatsHCTable_s, ASN_UNSIGNED, wrsPstatsHCIndex), /* not reported */
+	FIELD(wrsPstatsHCTable_s, ASN_OCTET_STR, wrsPstatsHCPortName),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCTXUnderrun),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRXOverrun),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRXInvalidCode),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRXSyncLost),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRXPauseFrames),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRXPfilterDropped),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRXPCSErrors),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRXGiantFrames),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRXRuntFrames),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRXCRCErrors),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRXPclass0),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRXPclass1),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRXPclass2),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRXPclass3),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRXPclass4),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRXPclass5),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRXPclass6),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRXPclass7),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCTXFrames),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRXFrames),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRXDropRTUFull),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRXPrio0),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRXPrio1),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRXPrio2),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRXPrio3),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRXPrio4),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRXPrio5),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRXPrio6),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRXPrio7),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRTUValid),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRTUResponses),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCRTUDropped),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCFastMatchPriority),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCFastMatchFastForward),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCFastMatchNonForward),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCFastMatchRespValid),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCFullMatchRespValid),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCForwarded),
+	FIELD(wrsPstatsHCTable_s, ASN_COUNTER64, wrsPstatsHCTRURespValid),
 };
 
 time_t
@@ -107,7 +107,7 @@ wrsPstatsHCTable_data_fill(unsigned int *n_rows)
 
 	/* read pstats for each port */
 	for (wrport = 0; wrport < WRS_N_PORTS; wrport++) {
-		snprintf(pstats_array[wrport].port_name, 10,
+		snprintf(pstats_array[wrport].wrsPstatsHCPortName, 10,
 				 "wri%d", wrport + 1);
 		sprintf(fname, PSTATS_SYSCTL_PATH"wrport%i", wrport + 1);
 		f = fopen(fname, "r");
@@ -137,45 +137,45 @@ wrsPstatsHCTable_data_fill(unsigned int *n_rows)
 		switch (counters_version) {
 		case 1:
 			/* copy counters to array */
-			pstats_array[wrport].TXUnderrun = counters[0];
-			pstats_array[wrport].RXOverrun = counters[1];
-			pstats_array[wrport].RXInvalidCode = counters[2];
-			pstats_array[wrport].RXSyncLost = counters[3];
-			pstats_array[wrport].RXPauseFrames = counters[4];
-			pstats_array[wrport].RXPfilterDropped = counters[5];
-			pstats_array[wrport].RXPCSErrors = counters[6];
-			pstats_array[wrport].RXGiantFrames = counters[7];
-			pstats_array[wrport].RXRuntFrames = counters[8];
-			pstats_array[wrport].RXCRCErrors = counters[9];
-			pstats_array[wrport].RXPclass0 = counters[10];
-			pstats_array[wrport].RXPclass1 = counters[11];
-			pstats_array[wrport].RXPclass2 = counters[12];
-			pstats_array[wrport].RXPclass3 = counters[13];
-			pstats_array[wrport].RXPclass4 = counters[14];
-			pstats_array[wrport].RXPclass5 = counters[15];
-			pstats_array[wrport].RXPclass6 = counters[16];
-			pstats_array[wrport].RXPclass7 = counters[17];
-			pstats_array[wrport].TXFrames = counters[18];
-			pstats_array[wrport].RXFrames = counters[19];
-			pstats_array[wrport].RXDropRTUFull = counters[20];
-			pstats_array[wrport].RXPrio0 = counters[21];
-			pstats_array[wrport].RXPrio1 = counters[22];
-			pstats_array[wrport].RXPrio2 = counters[23];
-			pstats_array[wrport].RXPrio3 = counters[24];
-			pstats_array[wrport].RXPrio4 = counters[25];
-			pstats_array[wrport].RXPrio5 = counters[26];
-			pstats_array[wrport].RXPrio6 = counters[27];
-			pstats_array[wrport].RXPrio7 = counters[28];
-			pstats_array[wrport].RTUValid = counters[29];
-			pstats_array[wrport].RTUResponses = counters[30];
-			pstats_array[wrport].RTUDropped = counters[31];
-			pstats_array[wrport].FastMatchPriority = counters[32];
-			pstats_array[wrport].FastMatchFastForward = counters[33];
-			pstats_array[wrport].FastMatchNonForward = counters[34];
-			pstats_array[wrport].FastMatchRespValid = counters[35];
-			pstats_array[wrport].FullMatchRespValid = counters[36];
-			pstats_array[wrport].Forwarded = counters[37];
-			pstats_array[wrport].TRURespValid = counters[38];
+			pstats_array[wrport].wrsPstatsHCTXUnderrun = counters[0];
+			pstats_array[wrport].wrsPstatsHCRXOverrun = counters[1];
+			pstats_array[wrport].wrsPstatsHCRXInvalidCode = counters[2];
+			pstats_array[wrport].wrsPstatsHCRXSyncLost = counters[3];
+			pstats_array[wrport].wrsPstatsHCRXPauseFrames = counters[4];
+			pstats_array[wrport].wrsPstatsHCRXPfilterDropped = counters[5];
+			pstats_array[wrport].wrsPstatsHCRXPCSErrors = counters[6];
+			pstats_array[wrport].wrsPstatsHCRXGiantFrames = counters[7];
+			pstats_array[wrport].wrsPstatsHCRXRuntFrames = counters[8];
+			pstats_array[wrport].wrsPstatsHCRXCRCErrors = counters[9];
+			pstats_array[wrport].wrsPstatsHCRXPclass0 = counters[10];
+			pstats_array[wrport].wrsPstatsHCRXPclass1 = counters[11];
+			pstats_array[wrport].wrsPstatsHCRXPclass2 = counters[12];
+			pstats_array[wrport].wrsPstatsHCRXPclass3 = counters[13];
+			pstats_array[wrport].wrsPstatsHCRXPclass4 = counters[14];
+			pstats_array[wrport].wrsPstatsHCRXPclass5 = counters[15];
+			pstats_array[wrport].wrsPstatsHCRXPclass6 = counters[16];
+			pstats_array[wrport].wrsPstatsHCRXPclass7 = counters[17];
+			pstats_array[wrport].wrsPstatsHCTXFrames = counters[18];
+			pstats_array[wrport].wrsPstatsHCRXFrames = counters[19];
+			pstats_array[wrport].wrsPstatsHCRXDropRTUFull = counters[20];
+			pstats_array[wrport].wrsPstatsHCRXPrio0 = counters[21];
+			pstats_array[wrport].wrsPstatsHCRXPrio1 = counters[22];
+			pstats_array[wrport].wrsPstatsHCRXPrio2 = counters[23];
+			pstats_array[wrport].wrsPstatsHCRXPrio3 = counters[24];
+			pstats_array[wrport].wrsPstatsHCRXPrio4 = counters[25];
+			pstats_array[wrport].wrsPstatsHCRXPrio5 = counters[26];
+			pstats_array[wrport].wrsPstatsHCRXPrio6 = counters[27];
+			pstats_array[wrport].wrsPstatsHCRXPrio7 = counters[28];
+			pstats_array[wrport].wrsPstatsHCRTUValid = counters[29];
+			pstats_array[wrport].wrsPstatsHCRTUResponses = counters[30];
+			pstats_array[wrport].wrsPstatsHCRTUDropped = counters[31];
+			pstats_array[wrport].wrsPstatsHCFastMatchPriority = counters[32];
+			pstats_array[wrport].wrsPstatsHCFastMatchFastForward = counters[33];
+			pstats_array[wrport].wrsPstatsHCFastMatchNonForward = counters[34];
+			pstats_array[wrport].wrsPstatsHCFastMatchRespValid = counters[35];
+			pstats_array[wrport].wrsPstatsHCFullMatchRespValid = counters[36];
+			pstats_array[wrport].wrsPstatsHCForwarded = counters[37];
+			pstats_array[wrport].wrsPstatsHCTRURespValid = counters[38];
 			break;
 		case 2:
 		default:
diff --git a/userspace/snmpd/wrsPstatsHCTable.h b/userspace/snmpd/wrsPstatsHCTable.h
index 5160a175a009914fc4162a7d552a17efe08de4bb..95424ef485ff0172998fb9906ec86af28ad63e80 100644
--- a/userspace/snmpd/wrsPstatsHCTable.h
+++ b/userspace/snmpd/wrsPstatsHCTable.h
@@ -11,48 +11,48 @@
 
 
 struct wrsPstatsHCTable_s {
-	uint32_t index;		/* not reported, index fields has to be marked
-				 * as not-accessible in MIB */
-	char port_name[12];	/* port name of counters */
-	uint64_t TXUnderrun;
-	uint64_t RXOverrun;
-	uint64_t RXInvalidCode;
-	uint64_t RXSyncLost;
-	uint64_t RXPauseFrames;
-	uint64_t RXPfilterDropped;
-	uint64_t RXPCSErrors;
-	uint64_t RXGiantFrames;
-	uint64_t RXRuntFrames;
-	uint64_t RXCRCErrors;
-	uint64_t RXPclass0;
-	uint64_t RXPclass1;
-	uint64_t RXPclass2;
-	uint64_t RXPclass3;
-	uint64_t RXPclass4;
-	uint64_t RXPclass5;
-	uint64_t RXPclass6;
-	uint64_t RXPclass7;
-	uint64_t TXFrames;
-	uint64_t RXFrames;
-	uint64_t RXDropRTUFull;
-	uint64_t RXPrio0;
-	uint64_t RXPrio1;
-	uint64_t RXPrio2;
-	uint64_t RXPrio3;
-	uint64_t RXPrio4;
-	uint64_t RXPrio5;
-	uint64_t RXPrio6;
-	uint64_t RXPrio7;
-	uint64_t RTUValid;
-	uint64_t RTUResponses;
-	uint64_t RTUDropped;
-	uint64_t FastMatchPriority;
-	uint64_t FastMatchFastForward;
-	uint64_t FastMatchNonForward;
-	uint64_t FastMatchRespValid;
-	uint64_t FullMatchRespValid;
-	uint64_t Forwarded;
-	uint64_t TRURespValid;
+	uint32_t wrsPstatsHCIndex; /* not reported, index fields has to be marked
+				  * as not-accessible in MIB */
+	char wrsPstatsHCPortName[12];	/* port name of counters */
+	uint64_t wrsPstatsHCTXUnderrun;
+	uint64_t wrsPstatsHCRXOverrun;
+	uint64_t wrsPstatsHCRXInvalidCode;
+	uint64_t wrsPstatsHCRXSyncLost;
+	uint64_t wrsPstatsHCRXPauseFrames;
+	uint64_t wrsPstatsHCRXPfilterDropped;
+	uint64_t wrsPstatsHCRXPCSErrors;
+	uint64_t wrsPstatsHCRXGiantFrames;
+	uint64_t wrsPstatsHCRXRuntFrames;
+	uint64_t wrsPstatsHCRXCRCErrors;
+	uint64_t wrsPstatsHCRXPclass0;
+	uint64_t wrsPstatsHCRXPclass1;
+	uint64_t wrsPstatsHCRXPclass2;
+	uint64_t wrsPstatsHCRXPclass3;
+	uint64_t wrsPstatsHCRXPclass4;
+	uint64_t wrsPstatsHCRXPclass5;
+	uint64_t wrsPstatsHCRXPclass6;
+	uint64_t wrsPstatsHCRXPclass7;
+	uint64_t wrsPstatsHCTXFrames;
+	uint64_t wrsPstatsHCRXFrames;
+	uint64_t wrsPstatsHCRXDropRTUFull;
+	uint64_t wrsPstatsHCRXPrio0;
+	uint64_t wrsPstatsHCRXPrio1;
+	uint64_t wrsPstatsHCRXPrio2;
+	uint64_t wrsPstatsHCRXPrio3;
+	uint64_t wrsPstatsHCRXPrio4;
+	uint64_t wrsPstatsHCRXPrio5;
+	uint64_t wrsPstatsHCRXPrio6;
+	uint64_t wrsPstatsHCRXPrio7;
+	uint64_t wrsPstatsHCRTUValid;
+	uint64_t wrsPstatsHCRTUResponses;
+	uint64_t wrsPstatsHCRTUDropped;
+	uint64_t wrsPstatsHCFastMatchPriority;
+	uint64_t wrsPstatsHCFastMatchFastForward;
+	uint64_t wrsPstatsHCFastMatchNonForward;
+	uint64_t wrsPstatsHCFastMatchRespValid;
+	uint64_t wrsPstatsHCFullMatchRespValid;
+	uint64_t wrsPstatsHCForwarded;
+	uint64_t wrsPstatsHCTRURespValid;
 };
 
 extern struct wrsPstatsHCTable_s pstats_array[WRS_N_PORTS];
diff --git a/userspace/snmpd/wrsPtpDataTable.c b/userspace/snmpd/wrsPtpDataTable.c
index d7b79f3ad80d1e4e908aca18a8058cc0534e0e15..ebadb7ee4e33db0312946f944effc4e87711b657 100644
--- a/userspace/snmpd/wrsPtpDataTable.c
+++ b/userspace/snmpd/wrsPtpDataTable.c
@@ -6,29 +6,29 @@ struct wrsPtpDataTable_s wrsPtpDataTable_array[WRS_MAX_N_SERVO_INSTANCES];
 
 static struct pickinfo wrsPtpDataTable_pickinfo[] = {
 	/* Warning: strings are a special case for snmp format */
-	FIELD(wrsPtpDataTable_s, ASN_UNSIGNED, index), /* not reported */
-	FIELD(wrsPtpDataTable_s, ASN_OCTET_STR, port_name),
-	FIELD(wrsPtpDataTable_s, ASN_OCTET_STR, gm_id),
-	FIELD(wrsPtpDataTable_s, ASN_OCTET_STR, my_id),
-	FIELD(wrsPtpDataTable_s, ASN_INTEGER, ppsi_mode),
-	FIELD(wrsPtpDataTable_s, ASN_OCTET_STR, servo_state_name),
-	FIELD(wrsPtpDataTable_s, ASN_INTEGER, servo_state),
-	FIELD(wrsPtpDataTable_s, ASN_INTEGER, tracking_enabled),
-	FIELD(wrsPtpDataTable_s, ASN_OCTET_STR, sync_source),
-	FIELD(wrsPtpDataTable_s, ASN_COUNTER64, clock_offset),
-	FIELD(wrsPtpDataTable_s, ASN_INTEGER, clock_offsetHR),
-	FIELD(wrsPtpDataTable_s, ASN_INTEGER, skew),
-	FIELD(wrsPtpDataTable_s, ASN_COUNTER64, rtt),
-	FIELD(wrsPtpDataTable_s, ASN_UNSIGNED, llength),
-	FIELD(wrsPtpDataTable_s, ASN_COUNTER, servo_updates),
-	FIELD(wrsPtpDataTable_s, ASN_INTEGER, delta_tx_m),
-	FIELD(wrsPtpDataTable_s, ASN_INTEGER, delta_rx_m),
-	FIELD(wrsPtpDataTable_s, ASN_INTEGER, delta_tx_s),
-	FIELD(wrsPtpDataTable_s, ASN_INTEGER, delta_rx_s),
-	FIELD(wrsPtpDataTable_s, ASN_COUNTER, n_err_state),
-	FIELD(wrsPtpDataTable_s, ASN_COUNTER, n_err_offset),
-	FIELD(wrsPtpDataTable_s, ASN_COUNTER, n_err_delta_rtt),
-	FIELD(wrsPtpDataTable_s, ASN_COUNTER64, update_time),
+	FIELD(wrsPtpDataTable_s, ASN_UNSIGNED, wrsPtpDataIndex), /* not reported */
+	FIELD(wrsPtpDataTable_s, ASN_OCTET_STR, wrsPtpPortName),
+	FIELD(wrsPtpDataTable_s, ASN_OCTET_STR, wrsPtpGrandmasterID),
+	FIELD(wrsPtpDataTable_s, ASN_OCTET_STR, wrsPtpOwnID),
+	FIELD(wrsPtpDataTable_s, ASN_INTEGER, wrsPtpMode),
+	FIELD(wrsPtpDataTable_s, ASN_OCTET_STR, wrsPtpServoState),
+	FIELD(wrsPtpDataTable_s, ASN_INTEGER, wrsPtpServoStateN),
+	FIELD(wrsPtpDataTable_s, ASN_INTEGER, wrsPtpPhaseTracking),
+	FIELD(wrsPtpDataTable_s, ASN_OCTET_STR, wrsPtpSyncSource),
+	FIELD(wrsPtpDataTable_s, ASN_COUNTER64, wrsPtpClockOffsetPs),
+	FIELD(wrsPtpDataTable_s, ASN_INTEGER, wrsPtpClockOffsetPsHR),
+	FIELD(wrsPtpDataTable_s, ASN_INTEGER, wrsPtpSkew),
+	FIELD(wrsPtpDataTable_s, ASN_COUNTER64, wrsPtpRTT),
+	FIELD(wrsPtpDataTable_s, ASN_UNSIGNED, wrsPtpLinkLength),
+	FIELD(wrsPtpDataTable_s, ASN_COUNTER, wrsPtpServoUpdates),
+	FIELD(wrsPtpDataTable_s, ASN_INTEGER, wrsPtpDeltaTxM),
+	FIELD(wrsPtpDataTable_s, ASN_INTEGER, wrsPtpDeltaRxM),
+	FIELD(wrsPtpDataTable_s, ASN_INTEGER, wrsPtpDeltaTxS),
+	FIELD(wrsPtpDataTable_s, ASN_INTEGER, wrsPtpDeltaRxS),
+	FIELD(wrsPtpDataTable_s, ASN_COUNTER, wrsPtpServoStateErrCnt),
+	FIELD(wrsPtpDataTable_s, ASN_COUNTER, wrsPtpClockOffsetErrCnt),
+	FIELD(wrsPtpDataTable_s, ASN_COUNTER, wrsPtpRTTErrCnt),
+	FIELD(wrsPtpDataTable_s, ASN_COUNTER64, wrsPtpServoUpdateTime),
 
 };
 
@@ -81,38 +81,39 @@ time_t wrsPtpDataTable_data_fill(unsigned int *n_rows)
 	while (1) {
 		ii = wrs_shm_seqbegin(ppsi_head);
 
-		strncpy(wrsPtpDataTable_array[0].servo_state_name,
+		strncpy(wrsPtpDataTable_array[0].wrsPtpServoState,
 			ppsi_servo->servo_state_name,
 			sizeof(ppsi_servo->servo_state_name));
-		wrsPtpDataTable_array[0].servo_state = ppsi_servo->state;
+		wrsPtpDataTable_array[0].wrsPtpServoStateN = ppsi_servo->state;
 		/* Keep value 0 for Not available */
-		wrsPtpDataTable_array[0].tracking_enabled =
+		wrsPtpDataTable_array[0].wrsPtpPhaseTracking =
 					1 + ppsi_servo->tracking_enabled;
 		/*
 		 * WARNING: the current snmpd is bugged: it has
 		 * endianness problems with 64 bit, and the two
 		 * halves are swapped. So pre-swap them here
 		 */
-		wrsPtpDataTable_array[0].rtt = (ppsi_servo->picos_mu << 32)
+		wrsPtpDataTable_array[0].wrsPtpRTT = (ppsi_servo->picos_mu << 32)
 				    | (ppsi_servo->picos_mu >> 32);
-		wrsPtpDataTable_array[0].clock_offset =
+		wrsPtpDataTable_array[0].wrsPtpClockOffsetPs =
 						(ppsi_servo->offset << 32)
 						| (ppsi_servo->offset >> 32);
-		wrsPtpDataTable_array[0].clock_offsetHR =
+		wrsPtpDataTable_array[0].wrsPtpClockOffsetPsHR =
 					int_saturate(ppsi_servo->offset);
-		wrsPtpDataTable_array[0].skew = int_saturate(ppsi_servo->skew);
-		wrsPtpDataTable_array[0].llength =
+		wrsPtpDataTable_array[0].wrsPtpSkew =
+						int_saturate(ppsi_servo->skew);
+		wrsPtpDataTable_array[0].wrsPtpLinkLength =
 			(uint32_t)(ppsi_servo->delta_ms/1e12 * 300e6 / 1.55);
-		wrsPtpDataTable_array[0].servo_updates =
+		wrsPtpDataTable_array[0].wrsPtpServoUpdates =
 						ppsi_servo->update_count;
-		wrsPtpDataTable_array[0].delta_tx_m = ppsi_servo->delta_tx_m;
-		wrsPtpDataTable_array[0].delta_rx_m = ppsi_servo->delta_rx_m;
-		wrsPtpDataTable_array[0].delta_tx_s = ppsi_servo->delta_tx_s;
-		wrsPtpDataTable_array[0].delta_rx_s = ppsi_servo->delta_rx_s;
-		wrsPtpDataTable_array[0].n_err_state = ppsi_servo->n_err_state;
-		wrsPtpDataTable_array[0].n_err_offset = ppsi_servo->n_err_offset;
-		wrsPtpDataTable_array[0].n_err_delta_rtt = ppsi_servo->n_err_delta_rtt;
-		wrsPtpDataTable_array[0].update_time =
+		wrsPtpDataTable_array[0].wrsPtpDeltaTxM = ppsi_servo->delta_tx_m;
+		wrsPtpDataTable_array[0].wrsPtpDeltaRxM = ppsi_servo->delta_rx_m;
+		wrsPtpDataTable_array[0].wrsPtpDeltaTxS = ppsi_servo->delta_tx_s;
+		wrsPtpDataTable_array[0].wrsPtpDeltaRxS = ppsi_servo->delta_rx_s;
+		wrsPtpDataTable_array[0].wrsPtpServoStateErrCnt = ppsi_servo->n_err_state;
+		wrsPtpDataTable_array[0].wrsPtpClockOffsetErrCnt = ppsi_servo->n_err_offset;
+		wrsPtpDataTable_array[0].wrsPtpRTTErrCnt = ppsi_servo->n_err_delta_rtt;
+		wrsPtpDataTable_array[0].wrsPtpServoUpdateTime =
 			(((uint64_t) ppsi_servo->update_time.seconds) * 1000000000LL)
 			+ ppsi_servo->update_time.nanoseconds;
 		retries++;
diff --git a/userspace/snmpd/wrsPtpDataTable.h b/userspace/snmpd/wrsPtpDataTable.h
index 931ce469e25ac07d56b03e2e6d962db993d30b45..145f5b920f60bc826925dc9485b60fc6adb3d79f 100644
--- a/userspace/snmpd/wrsPtpDataTable.h
+++ b/userspace/snmpd/wrsPtpDataTable.h
@@ -8,32 +8,32 @@
 #define WRS_MAX_N_SERVO_INSTANCES 1
 
 struct wrsPtpDataTable_s {
-	uint32_t index;		/* not reported, index fields has to be marked
+	uint32_t wrsPtpDataIndex;		/* not reported, index fields has to be marked
 				 * as not-accessible in MIB */
-	char port_name[12];	/* port name on which ptp servo instance in
+	char wrsPtpPortName[12];	/* port name on which ptp servo instance in
 				 * running FIXME: not implemented */
-	ClockIdentity gm_id;	/* FIXME: not implemented */
-	ClockIdentity my_id;	/* FIXME: not implemented */
-	int ppsi_mode;		/* FIXME: not implemented */
-	char servo_state_name[32]; /* State as string */
-	int servo_state;	/* state number */
-	int tracking_enabled;
-	char sync_source[32];	/* FIXME: not implemented */
-	int64_t clock_offset;
-	int32_t clock_offsetHR;	/* Human readable version of clock_offset,
+	ClockIdentity wrsPtpGrandmasterID;	/* FIXME: not implemented */
+	ClockIdentity wrsPtpOwnID;	/* FIXME: not implemented */
+	int wrsPtpMode;		/* FIXME: not implemented */
+	char wrsPtpServoState[32]; /* State as string */
+	int wrsPtpServoStateN;	/* state number */
+	int wrsPtpPhaseTracking;
+	char wrsPtpSyncSource[32];	/* FIXME: not implemented */
+	int64_t wrsPtpClockOffsetPs;
+	int32_t wrsPtpClockOffsetPsHR;	/* Human readable version of clock_offset,
 				 * saturated to int limits */
-	int32_t skew;
-	int64_t rtt;
-	uint32_t llength;
-	uint32_t servo_updates;
-	int32_t delta_tx_m;
-	int32_t delta_rx_m;
-	int32_t delta_tx_s;
-	int32_t delta_rx_s;
-	uint32_t n_err_state;
-	uint32_t n_err_offset;
-	uint32_t n_err_delta_rtt;
-	uint64_t update_time;
+	int32_t wrsPtpSkew;
+	int64_t wrsPtpRTT;
+	uint32_t wrsPtpLinkLength;
+	uint32_t wrsPtpServoUpdates;
+	int32_t wrsPtpDeltaTxM;
+	int32_t wrsPtpDeltaRxM;
+	int32_t wrsPtpDeltaTxS;
+	int32_t wrsPtpDeltaRxS;
+	uint32_t wrsPtpServoStateErrCnt;
+	uint32_t wrsPtpClockOffsetErrCnt;
+	uint32_t wrsPtpRTTErrCnt;
+	uint64_t wrsPtpServoUpdateTime;
 };
 
 extern struct wrsPtpDataTable_s wrsPtpDataTable_array[WRS_MAX_N_SERVO_INSTANCES];
diff --git a/userspace/snmpd/wrsSpllVersionGroup.c b/userspace/snmpd/wrsSpllVersionGroup.c
index 8673d0bc9aac8159ddef7073f4c778d4637e9104..b62334a6c6587ed943f68900ded8ae2279d205cf 100644
--- a/userspace/snmpd/wrsSpllVersionGroup.c
+++ b/userspace/snmpd/wrsSpllVersionGroup.c
@@ -9,9 +9,9 @@
 static struct spll_stats *spll_stats_p;
 
 static struct pickinfo wrsSpllVersion_pickinfo[] = {
-	FIELD(wrsSpllVersion_s, ASN_OCTET_STR, commit_id),
-	FIELD(wrsSpllVersion_s, ASN_OCTET_STR, build_date),
-	FIELD(wrsSpllVersion_s, ASN_OCTET_STR, build_by),
+	FIELD(wrsSpllVersion_s, ASN_OCTET_STR, wrsSpllVersion),
+	FIELD(wrsSpllVersion_s, ASN_OCTET_STR, wrsSpllBuildDate),
+	FIELD(wrsSpllVersion_s, ASN_OCTET_STR, wrsSpllBuildBy),
 };
 
 struct wrsSpllVersion_s wrsSpllVersion_s;
@@ -63,17 +63,17 @@ time_t wrsSpllVersion_data_fill(void)
 	 * version 2 */
 	if (spll_stats_p->ver == 2 || spll_stats_p->ver == 3) {
 		int len;
-		strncpy_e(wrsSpllVersion_s.commit_id, spll_stats_p->commit_id, 32);
+		strncpy_e(wrsSpllVersion_s.wrsSpllVersion, spll_stats_p->commit_id, 32);
 		/* concatenate date and time */
-		strncpy_e(wrsSpllVersion_s.build_date, spll_stats_p->build_date, 16);
-		len = strnlen(wrsSpllVersion_s.build_date, 32);
-		wrsSpllVersion_s.build_date[len] = ' '; /* put space instead of null */
+		strncpy_e(wrsSpllVersion_s.wrsSpllBuildDate, spll_stats_p->build_date, 16);
+		len = strnlen(wrsSpllVersion_s.wrsSpllBuildDate, 32);
+		wrsSpllVersion_s.wrsSpllBuildDate[len] = ' '; /* put space instead of null */
 		/* add time after added space at the end of string */
-		strncpy_e(&wrsSpllVersion_s.build_date[len + 1], spll_stats_p->build_time, 16 - 1);
+		strncpy_e(&wrsSpllVersion_s.wrsSpllBuildDate[len + 1], spll_stats_p->build_time, 16 - 1);
 	}
 	/* buil_by was introduced in version 3 */
 	if (spll_stats_p->ver == 3) {
-		strncpy_e(wrsSpllVersion_s.build_by, spll_stats_p->build_by, 32);
+		strncpy_e(wrsSpllVersion_s.wrsSpllBuildBy, spll_stats_p->build_by, 32);
 	}
 	/* there was an update, return current time */
 	return time_update;
diff --git a/userspace/snmpd/wrsSpllVersionGroup.h b/userspace/snmpd/wrsSpllVersionGroup.h
index 3bffa3bd5517e0070fe0b56d5e38d0e6e85ed17c..657a6726c9df8b50b7c1d1a85b0f823bb76b06f1 100644
--- a/userspace/snmpd/wrsSpllVersionGroup.h
+++ b/userspace/snmpd/wrsSpllVersionGroup.h
@@ -5,9 +5,9 @@
 #define WRSSPLLVERSION_OID WRS_OID, 7, 3, 1
 
 struct wrsSpllVersion_s {
-	char commit_id[32];
-	char build_date[32];
-	char build_by[32];
+	char wrsSpllVersion[32];
+	char wrsSpllBuildDate[32];
+	char wrsSpllBuildBy[32];
 };
 
 extern struct wrsSpllVersion_s wrsSpllVersion_s;
diff --git a/userspace/snmpd/wrsTemperatureGroup.c b/userspace/snmpd/wrsTemperatureGroup.c
index d7a3f9cdb4cd4dcc766f4956b3d3d7977dca7731..f1b10c290901ceb380f938ba7bb7a2913dadf903 100644
--- a/userspace/snmpd/wrsTemperatureGroup.c
+++ b/userspace/snmpd/wrsTemperatureGroup.c
@@ -4,14 +4,14 @@
 #include <libwr/config.h>
 
 static struct pickinfo wrsTemperature_pickinfo[] = {
-	FIELD(wrsTemperature_s, ASN_INTEGER, temp_fpga),
-	FIELD(wrsTemperature_s, ASN_INTEGER, temp_pll),
-	FIELD(wrsTemperature_s, ASN_INTEGER, temp_psl),
-	FIELD(wrsTemperature_s, ASN_INTEGER, temp_psr),
-	FIELD(wrsTemperature_s, ASN_INTEGER, temp_fpga_thold),
-	FIELD(wrsTemperature_s, ASN_INTEGER, temp_pll_thold),
-	FIELD(wrsTemperature_s, ASN_INTEGER, temp_psl_thold),
-	FIELD(wrsTemperature_s, ASN_INTEGER, temp_psr_thold),
+	FIELD(wrsTemperature_s, ASN_INTEGER, wrsTempFPGA),
+	FIELD(wrsTemperature_s, ASN_INTEGER, wrsTempPLL),
+	FIELD(wrsTemperature_s, ASN_INTEGER, wrsTempPSL),
+	FIELD(wrsTemperature_s, ASN_INTEGER, wrsTempPSR),
+	FIELD(wrsTemperature_s, ASN_INTEGER, wrsTempThresholdFPGA),
+	FIELD(wrsTemperature_s, ASN_INTEGER, wrsTempThresholdPLL),
+	FIELD(wrsTemperature_s, ASN_INTEGER, wrsTempThresholdPSL),
+	FIELD(wrsTemperature_s, ASN_INTEGER, wrsTempThresholdPSR),
 };
 
 struct wrsTemperature_s wrsTemperature_s;
@@ -22,16 +22,16 @@ static void get_thresholds(void)
 	/* check wether config fields exist, atoi has to have valid string */
 	config_item = libwr_cfg_get("SNMP_TEMP_THOLD_FPGA");
 	if (config_item)
-		wrsTemperature_s.temp_fpga_thold = atoi(config_item);
+		wrsTemperature_s.wrsTempThresholdFPGA = atoi(config_item);
 	config_item = libwr_cfg_get("SNMP_TEMP_THOLD_PLL");
 	if (config_item)
-		wrsTemperature_s.temp_pll_thold = atoi(config_item);
+		wrsTemperature_s.wrsTempThresholdPLL = atoi(config_item);
 	config_item = libwr_cfg_get("SNMP_TEMP_THOLD_PSL");
 	if (config_item)
-		wrsTemperature_s.temp_psl_thold = atoi(config_item);
+		wrsTemperature_s.wrsTempThresholdPSL = atoi(config_item);
 	config_item = libwr_cfg_get("SNMP_TEMP_THOLD_PSR");
 	if (config_item)
-		wrsTemperature_s.temp_psr_thold = atoi(config_item);
+		wrsTemperature_s.wrsTempThresholdPSR = atoi(config_item);
 }
 
 time_t wrsTemperature_data_fill(void)
@@ -65,10 +65,10 @@ time_t wrsTemperature_data_fill(void)
 	while (1) {
 		ii = wrs_shm_seqbegin(hal_head);
 
-		wrsTemperature_s.temp_fpga = hal_shmem->temp.fpga >> 8;
-		wrsTemperature_s.temp_pll = hal_shmem->temp.pll >> 8;
-		wrsTemperature_s.temp_psl = hal_shmem->temp.psl >> 8;
-		wrsTemperature_s.temp_psr = hal_shmem->temp.psr >> 8;
+		wrsTemperature_s.wrsTempFPGA = hal_shmem->temp.fpga >> 8;
+		wrsTemperature_s.wrsTempPLL = hal_shmem->temp.pll >> 8;
+		wrsTemperature_s.wrsTempPSL = hal_shmem->temp.psl >> 8;
+		wrsTemperature_s.wrsTempPSR = hal_shmem->temp.psr >> 8;
 
 		retries++;
 		if (retries > 100) {
diff --git a/userspace/snmpd/wrsTemperatureGroup.h b/userspace/snmpd/wrsTemperatureGroup.h
index f84a1f75043af7447407ec98b3521d567f647216..cc3c94d015c7e4c2278be30284b1f78988fd9191 100644
--- a/userspace/snmpd/wrsTemperatureGroup.h
+++ b/userspace/snmpd/wrsTemperatureGroup.h
@@ -5,14 +5,14 @@
 #define WRSTEMPERATURE_OID WRS_OID, 7, 1, 3
 
 struct wrsTemperature_s {
-	int temp_fpga;		/* FPGA temperature */
-	int temp_pll;		/* PLL temperature */
-	int temp_psl;		/* PSL temperature */
-	int temp_psr;		/* PSR temperature */
-	int temp_fpga_thold;	/* Threshold value for FPGA temperature */
-	int temp_pll_thold;	/* Threshold value for PLL temperature */
-	int temp_psl_thold;	/* Threshold value for PSL temperature */
-	int temp_psr_thold;	/* Threshold value for PSR temperature */
+	int wrsTempFPGA;		/* FPGA temperature */
+	int wrsTempPLL;			/* PLL temperature */
+	int wrsTempPSL;			/* PSL temperature */
+	int wrsTempPSR;			/* PSR temperature */
+	int wrsTempThresholdFPGA;	/* Threshold value for FPGA temperature */
+	int wrsTempThresholdPLL;	/* Threshold value for PLL temperature */
+	int wrsTempThresholdPSL;	/* Threshold value for PSL temperature */
+	int wrsTempThresholdPSR;	/* Threshold value for PSR temperature */
 };
 
 extern struct wrsTemperature_s wrsTemperature_s;
diff --git a/userspace/snmpd/wrsTimingStatusGroup.c b/userspace/snmpd/wrsTimingStatusGroup.c
index 9116afd68e51c415cc266c19872fa00db00d47f6..30805f8fbbe650ff007cd1b0246a6d83efe4ffe8 100644
--- a/userspace/snmpd/wrsTimingStatusGroup.c
+++ b/userspace/snmpd/wrsTimingStatusGroup.c
@@ -86,10 +86,10 @@ static void get_wrsPTPStatus(unsigned int ptp_data_nrows)
 	static int first_run = 1;
 
 	/* store old values of ptp servo error counters and number of updates */
-	static uint32_t servo_updates_prev[WRS_MAX_N_SERVO_INSTANCES];
-	static uint32_t n_err_state_prev[WRS_MAX_N_SERVO_INSTANCES];
-	static uint32_t n_err_offset_prev[WRS_MAX_N_SERVO_INSTANCES];
-	static uint32_t n_err_delta_rtt_prev[WRS_MAX_N_SERVO_INSTANCES];
+	static uint32_t wrsPtpServoUpdates_prev[WRS_MAX_N_SERVO_INSTANCES];
+	static uint32_t wrsPtpServoStateErrCnt_prev[WRS_MAX_N_SERVO_INSTANCES];
+	static uint32_t wrsPtpClockOffsetErrCnt_prev[WRS_MAX_N_SERVO_INSTANCES];
+	static uint32_t wrsPtpRTTErrCnt_prev[WRS_MAX_N_SERVO_INSTANCES];
 
 	/*********************************************************************\
 	|*************************** wrsPTPStatus  ***************************|
@@ -113,14 +113,14 @@ static void get_wrsPTPStatus(unsigned int ptp_data_nrows)
 
 		/* check if error */
 		} else if ((s->wrsSpllMode == WRS_SPLL_MODE_SLAVE)
-		    && ((pd_a[i].servo_updates == servo_updates_prev[i])
-			|| (pd_a[i].n_err_state != n_err_state_prev[i])
-			|| (pd_a[i].n_err_offset != n_err_offset_prev[i])
-			|| (pd_a[i].n_err_delta_rtt != n_err_delta_rtt_prev[i])
-			|| (pd_a[i].delta_tx_m == 0)
-			|| (pd_a[i].delta_rx_m == 0)
-			|| (pd_a[i].delta_tx_s == 0)
-			|| (pd_a[i].delta_rx_s == 0))) {
+		    && ((pd_a[i].wrsPtpServoUpdates == wrsPtpServoUpdates_prev[i])
+			|| (pd_a[i].wrsPtpServoStateErrCnt != wrsPtpServoStateErrCnt_prev[i])
+			|| (pd_a[i].wrsPtpClockOffsetErrCnt != wrsPtpClockOffsetErrCnt_prev[i])
+			|| (pd_a[i].wrsPtpRTTErrCnt != wrsPtpRTTErrCnt_prev[i])
+			|| (pd_a[i].wrsPtpDeltaTxM == 0)
+			|| (pd_a[i].wrsPtpDeltaRxM == 0)
+			|| (pd_a[i].wrsPtpDeltaTxS == 0)
+			|| (pd_a[i].wrsPtpDeltaRxS == 0))) {
 			wrsTimingStatus_s.wrsPTPStatus = WRS_PTP_STATUS_ERROR;
 			snmp_log(LOG_ERR, "SNMP: wrsPTPStatus "
 					  "failed for instance %d\n", i);
@@ -132,10 +132,10 @@ static void get_wrsPTPStatus(unsigned int ptp_data_nrows)
 
 	for (i = 0; i < ptp_data_nrows; i++) {
 		/* update old values */
-		servo_updates_prev[i] = pd_a[i].servo_updates;
-		n_err_state_prev[i] = pd_a[i].n_err_state;
-		n_err_offset_prev[i] = pd_a[i].n_err_offset;
-		n_err_delta_rtt_prev[i] = pd_a[i].n_err_delta_rtt;
+		wrsPtpServoUpdates_prev[i] = pd_a[i].wrsPtpServoUpdates;
+		wrsPtpServoStateErrCnt_prev[i] = pd_a[i].wrsPtpServoStateErrCnt;
+		wrsPtpClockOffsetErrCnt_prev[i] = pd_a[i].wrsPtpClockOffsetErrCnt;
+		wrsPtpRTTErrCnt_prev[i] = pd_a[i].wrsPtpRTTErrCnt;
 	}
 
 	first_run = 0;
@@ -230,16 +230,16 @@ static void get_wrsSlaveLinksStatus(unsigned int port_status_nrows)
 		for (i = 0; i < port_status_nrows; i++) {
 			/* warning N/A */
 			if (/*hal_shmem->s->wrsSpllMode == 0
-			    || */p_a[i].port_mode == 0
-			    || p_a[i].link_up == 0){
+			    || */p_a[i].wrsPortStatusConfiguredMode == 0
+			    || p_a[i].wrsPortStatusLink == 0){
 				wrsTimingStatus_s.wrsSlaveLinksStatus =
 						WRS_SLAVE_LINK_STATUS_WARNING_NA;
 			}
 			/* error when slave port is down when switch is in slave mode
 			  */
 			if (hal_shmem->hal_mode == HAL_TIMING_MODE_BC
-			    && (p_a[i].port_mode == WRS_PORT_STATUS_CONFIGURED_MODE_SLAVE)
-			    && (p_a[i].link_up == WRS_PORT_STATUS_LINK_DOWN)) {
+			    && (p_a[i].wrsPortStatusConfiguredMode == WRS_PORT_STATUS_CONFIGURED_MODE_SLAVE)
+			    && (p_a[i].wrsPortStatusLink == WRS_PORT_STATUS_LINK_DOWN)) {
 				wrsTimingStatus_s.wrsSlaveLinksStatus =
 							WRS_SLAVE_LINK_STATUS_ERROR;
 				snmp_log(LOG_ERR, "SNMP: wrsSlaveLinksStatus (slave) "
@@ -249,8 +249,8 @@ static void get_wrsSlaveLinksStatus(unsigned int port_status_nrows)
 			/* error when slave port is up when switch is in master or
 			* grandmaster mode */
 			if (((hal_shmem->hal_mode == HAL_TIMING_MODE_GRAND_MASTER) || (hal_shmem->hal_mode == HAL_TIMING_MODE_FREE_MASTER))
-			    && (p_a[i].port_mode == WRS_PORT_STATUS_CONFIGURED_MODE_SLAVE)
-			    && (p_a[i].link_up == WRS_PORT_STATUS_LINK_UP)) {
+			    && (p_a[i].wrsPortStatusConfiguredMode == WRS_PORT_STATUS_CONFIGURED_MODE_SLAVE)
+			    && (p_a[i].wrsPortStatusLink == WRS_PORT_STATUS_LINK_UP)) {
 				wrsTimingStatus_s.wrsSlaveLinksStatus =
 							WRS_SLAVE_LINK_STATUS_ERROR;
 				snmp_log(LOG_ERR, "SNMP: wrsSlaveLinksStatus (master) "
@@ -268,8 +268,8 @@ static void get_wrsPTPFramesFlowing(unsigned int port_status_nrows)
 	static int first_run = 1;
 
 	/* store old values of TX and RX PTP counters to calculate delta */
-	static unsigned long ptp_tx_count_prev[WRS_N_PORTS];
-	static unsigned long ptp_rx_count_prev[WRS_N_PORTS];
+	static unsigned long wrsPortStatusPtpTxFrames_prev[WRS_N_PORTS];
+	static unsigned long wrsPortStatusPtpRxFrames_prev[WRS_N_PORTS];
 
 	/*********************************************************************\
 	|************************ wrsPTPFramesFlowing ************************|
@@ -290,10 +290,10 @@ static void get_wrsPTPFramesFlowing(unsigned int port_status_nrows)
 
 		/* Error when there is no increase in TX/RX PTP counters.
 		   Check only when port is non-wr and port is down */
-		} else if ((p_a[i].port_mode != WRS_PORT_STATUS_CONFIGURED_MODE_NON_WR)
-		    && (p_a[i].link_up == WRS_PORT_STATUS_LINK_UP)
-		    && ((ptp_tx_count_prev[i] == p_a[i].ptp_tx_count)
-			|| (ptp_rx_count_prev[i] == p_a[i].ptp_rx_count))) {
+		} else if ((p_a[i].wrsPortStatusConfiguredMode != WRS_PORT_STATUS_CONFIGURED_MODE_NON_WR)
+		    && (p_a[i].wrsPortStatusLink == WRS_PORT_STATUS_LINK_UP)
+		    && ((wrsPortStatusPtpTxFrames_prev[i] == p_a[i].wrsPortStatusPtpTxFrames)
+			|| (wrsPortStatusPtpRxFrames_prev[i] == p_a[i].wrsPortStatusPtpRxFrames))) {
 			wrsTimingStatus_s.wrsPTPFramesFlowing =
 						WRS_PTP_FRAMES_FLOWING_ERROR;
 			snmp_log(LOG_ERR, "SNMP: wrsPTPFramesFlowing "
@@ -303,8 +303,8 @@ static void get_wrsPTPFramesFlowing(unsigned int port_status_nrows)
 			break;
 
 		/* warning N/A */
-		} else if (p_a[i].port_mode == 0
-		    || p_a[i].link_up == 0){
+		} else if (p_a[i].wrsPortStatusConfiguredMode == 0
+		    || p_a[i].wrsPortStatusLink == 0){
 			wrsTimingStatus_s.wrsPTPFramesFlowing =
 					WRS_PTP_FRAMES_FLOWING_WARNING_NA;
 			/* continue with other ports, somewhere may be an
@@ -314,8 +314,8 @@ static void get_wrsPTPFramesFlowing(unsigned int port_status_nrows)
 
 	for (i = 0; i < port_status_nrows; i++) {
 		/* save current values */
-		ptp_tx_count_prev[i] = p_a[i].ptp_tx_count;
-		ptp_rx_count_prev[i] = p_a[i].ptp_rx_count;
+		wrsPortStatusPtpTxFrames_prev[i] = p_a[i].wrsPortStatusPtpTxFrames;
+		wrsPortStatusPtpRxFrames_prev[i] = p_a[i].wrsPortStatusPtpRxFrames;
 	}
 
 	first_run = 0;