diff --git a/libpldm/firmware_update.c b/libpldm/firmware_update.c
index 023fc4f..59d1f9d 100644
--- a/libpldm/firmware_update.c
+++ b/libpldm/firmware_update.c
@@ -336,8 +336,9 @@
 	    data_header->package_header_format_version;
 	package_header_info->package_header_size =
 	    le16toh(data_header->package_header_size);
-	memcpy(package_header_info->timestamp104, data_header->timestamp104,
-	       sizeof(data_header->timestamp104));
+	memcpy(package_header_info->package_release_date_time,
+	       data_header->package_release_date_time,
+	       sizeof(data_header->package_release_date_time));
 	package_header_info->component_bitmap_bit_length =
 	    le16toh(data_header->component_bitmap_bit_length);
 	package_header_info->package_version_string_type =
@@ -1083,14 +1084,14 @@
 int decode_update_component_resp(const struct pldm_msg *msg,
 				 size_t payload_length,
 				 uint8_t *completion_code,
-				 uint8_t *comp_compatability_resp,
-				 uint8_t *comp_compatability_resp_code,
+				 uint8_t *comp_compatibility_resp,
+				 uint8_t *comp_compatibility_resp_code,
 				 bitfield32_t *update_option_flags_enabled,
 				 uint16_t *time_before_req_fw_data)
 {
 	if (msg == NULL || completion_code == NULL ||
-	    comp_compatability_resp == NULL ||
-	    comp_compatability_resp_code == NULL ||
+	    comp_compatibility_resp == NULL ||
+	    comp_compatibility_resp_code == NULL ||
 	    update_option_flags_enabled == NULL ||
 	    time_before_req_fw_data == NULL || !payload_length) {
 		return PLDM_ERROR_INVALID_DATA;
@@ -1109,17 +1110,17 @@
 	    (struct pldm_update_component_resp *)msg->payload;
 
 	if (!is_comp_compatibility_resp_valid(
-		response->comp_compatability_resp)) {
+		response->comp_compatibility_resp)) {
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
 	if (!is_comp_compatibility_resp_code_valid(
-		response->comp_compatability_resp_code)) {
+		response->comp_compatibility_resp_code)) {
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	*comp_compatability_resp = response->comp_compatability_resp;
-	*comp_compatability_resp_code = response->comp_compatability_resp_code;
+	*comp_compatibility_resp = response->comp_compatibility_resp;
+	*comp_compatibility_resp_code = response->comp_compatibility_resp_code;
 	update_option_flags_enabled->value =
 	    le32toh(response->update_option_flags_enabled.value);
 	*time_before_req_fw_data = le16toh(response->time_before_req_fw_data);
diff --git a/libpldm/firmware_update.h b/libpldm/firmware_update.h
index a89ebbe..0dc5e4b 100644
--- a/libpldm/firmware_update.h
+++ b/libpldm/firmware_update.h
@@ -188,7 +188,7 @@
 /** @brief ComponentCompatibilityResponse values in the response of
  *         UpdateComponent
  */
-enum pldm_component_compatability_responses {
+enum pldm_component_compatibility_responses {
 	PLDM_CCR_COMP_CAN_BE_UPDATED = 0,
 	PLDM_CCR_COMP_CANNOT_BE_UPDATED = 1
 };
@@ -196,7 +196,7 @@
 /** @brief ComponentCompatibilityResponse Code values in the response of
  *         UpdateComponent
  */
-enum pldm_component_compatability_response_codes {
+enum pldm_component_compatibility_response_codes {
 	PLDM_CCRC_NO_RESPONSE_CODE = 0x00,
 	PLDM_CCRC_COMP_COMPARISON_STAMP_IDENTICAL = 0x01,
 	PLDM_CCRC_COMP_COMPARISON_STAMP_LOWER = 0x02,
@@ -326,7 +326,7 @@
 	uint8_t uuid[PLDM_FWUP_UUID_LENGTH];
 	uint8_t package_header_format_version;
 	uint16_t package_header_size;
-	uint8_t timestamp104[PLDM_TIMESTAMP104_SIZE];
+	uint8_t package_release_date_time[PLDM_TIMESTAMP104_SIZE];
 	uint16_t component_bitmap_bit_length;
 	uint8_t package_version_string_type;
 	uint8_t package_version_string_length;
@@ -494,8 +494,8 @@
  */
 struct pldm_update_component_resp {
 	uint8_t completion_code;
-	uint8_t comp_compatability_resp;
-	uint8_t comp_compatability_resp_code;
+	uint8_t comp_compatibility_resp;
+	uint8_t comp_compatibility_resp_code;
 	bitfield32_t update_option_flags_enabled;
 	uint16_t time_before_req_fw_data;
 } __attribute__((packed));
@@ -858,9 +858,9 @@
  *  @param[in] msg - Response message
  *  @param[in] payload_length - Length of response message payload
  *  @param[out] completion_code - Pointer to hold completion code
- *  @param[out] comp_compatability_resp - Pointer to hold component
+ *  @param[out] comp_compatibility_resp - Pointer to hold component
  *                                        compatibility response
- *  @param[out] comp_compatability_resp_code - Pointer to hold component
+ *  @param[out] comp_compatibility_resp_code - Pointer to hold component
  *                                             compatibility response code
  *  @param[out] update_option_flags_enabled - Pointer to hold
  *                                            UpdateOptionsFlagEnabled
@@ -872,8 +872,8 @@
 int decode_update_component_resp(const struct pldm_msg *msg,
 				 size_t payload_length,
 				 uint8_t *completion_code,
-				 uint8_t *comp_compatability_resp,
-				 uint8_t *comp_compatability_resp_code,
+				 uint8_t *comp_compatibility_resp,
+				 uint8_t *comp_compatibility_resp_code,
 				 bitfield32_t *update_option_flags_enabled,
 				 uint16_t *time_before_req_fw_data);
 
diff --git a/libpldm/platform.h b/libpldm/platform.h
index 8c95a27..e03d8c2 100644
--- a/libpldm/platform.h
+++ b/libpldm/platform.h
@@ -485,8 +485,8 @@
 	uint8_t minus_tolerance;
 	real32_t state_transition_interval;
 	real32_t transition_interval;
-	union_effecter_data_size max_set_table;
-	union_effecter_data_size min_set_table;
+	union_effecter_data_size max_settable;
+	union_effecter_data_size min_settable;
 	uint8_t range_field_format;
 	bitfield8_t range_field_support;
 	union_range_field_format nominal_value;
diff --git a/libpldm/tests/libpldm_firmware_update_test.cpp b/libpldm/tests/libpldm_firmware_update_test.cpp
index 24cbab1..756097f 100644
--- a/libpldm/tests/libpldm_firmware_update_test.cpp
+++ b/libpldm/tests/libpldm_firmware_update_test.cpp
@@ -19,7 +19,7 @@
     // Random PackageHeaderSize
     constexpr uint16_t pkgHeaderSize = 303;
     // PackageReleaseDateTime - "25/12/2021 00:00:00"
-    std::array<uint8_t, PLDM_TIMESTAMP104_SIZE> timestamp104{
+    std::array<uint8_t, PLDM_TIMESTAMP104_SIZE> package_release_date_time{
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x19, 0x0c, 0xe5, 0x07, 0x00};
     constexpr uint16_t componentBitmapBitLength = 8;
@@ -46,9 +46,11 @@
                          uuid.begin(), uuid.end()));
     EXPECT_EQ(pkgHeader.package_header_format_version, pkgHeaderFormatRevision);
     EXPECT_EQ(pkgHeader.package_header_size, pkgHeaderSize);
-    EXPECT_EQ(true, std::equal(pkgHeader.timestamp104,
-                               pkgHeader.timestamp104 + PLDM_TIMESTAMP104_SIZE,
-                               timestamp104.begin(), timestamp104.end()));
+    EXPECT_EQ(true, std::equal(pkgHeader.package_release_date_time,
+                               pkgHeader.package_release_date_time +
+                                   PLDM_TIMESTAMP104_SIZE,
+                               package_release_date_time.begin(),
+                               package_release_date_time.end()));
     EXPECT_EQ(pkgHeader.component_bitmap_bit_length, componentBitmapBitLength);
     EXPECT_EQ(pkgHeader.package_version_string_type, PLDM_STR_TYPE_ASCII);
     EXPECT_EQ(pkgHeader.package_version_string_length,
diff --git a/libpldmresponder/pdr_numeric_effecter.hpp b/libpldmresponder/pdr_numeric_effecter.hpp
index 6e85642..2819b07 100644
--- a/libpldmresponder/pdr_numeric_effecter.hpp
+++ b/libpldmresponder/pdr_numeric_effecter.hpp
@@ -106,28 +106,28 @@
         switch (pdr->effecter_data_size)
         {
             case PLDM_EFFECTER_DATA_SIZE_UINT8:
-                pdr->max_set_table.value_u8 = e.value("max_set_table", 0);
-                pdr->min_set_table.value_u8 = e.value("min_set_table", 0);
+                pdr->max_settable.value_u8 = e.value("max_settable", 0);
+                pdr->min_settable.value_u8 = e.value("min_settable", 0);
                 break;
             case PLDM_EFFECTER_DATA_SIZE_SINT8:
-                pdr->max_set_table.value_s8 = e.value("max_set_table", 0);
-                pdr->min_set_table.value_s8 = e.value("min_set_table", 0);
+                pdr->max_settable.value_s8 = e.value("max_settable", 0);
+                pdr->min_settable.value_s8 = e.value("min_settable", 0);
                 break;
             case PLDM_EFFECTER_DATA_SIZE_UINT16:
-                pdr->max_set_table.value_u16 = e.value("max_set_table", 0);
-                pdr->min_set_table.value_u16 = e.value("min_set_table", 0);
+                pdr->max_settable.value_u16 = e.value("max_settable", 0);
+                pdr->min_settable.value_u16 = e.value("min_settable", 0);
                 break;
             case PLDM_EFFECTER_DATA_SIZE_SINT16:
-                pdr->max_set_table.value_s16 = e.value("max_set_table", 0);
-                pdr->min_set_table.value_s16 = e.value("min_set_table", 0);
+                pdr->max_settable.value_s16 = e.value("max_settable", 0);
+                pdr->min_settable.value_s16 = e.value("min_settable", 0);
                 break;
             case PLDM_EFFECTER_DATA_SIZE_UINT32:
-                pdr->max_set_table.value_u32 = e.value("max_set_table", 0);
-                pdr->min_set_table.value_u32 = e.value("min_set_table", 0);
+                pdr->max_settable.value_u32 = e.value("max_settable", 0);
+                pdr->min_settable.value_u32 = e.value("min_settable", 0);
                 break;
             case PLDM_EFFECTER_DATA_SIZE_SINT32:
-                pdr->max_set_table.value_s32 = e.value("max_set_table", 0);
-                pdr->min_set_table.value_s32 = e.value("min_set_table", 0);
+                pdr->max_settable.value_s32 = e.value("max_settable", 0);
+                pdr->min_settable.value_s32 = e.value("min_settable", 0);
                 break;
             default:
                 break;
diff --git a/libpldmresponder/platform_numeric_effecter.hpp b/libpldmresponder/platform_numeric_effecter.hpp
index d07edda..51866ce 100644
--- a/libpldmresponder/platform_numeric_effecter.hpp
+++ b/libpldmresponder/platform_numeric_effecter.hpp
@@ -46,9 +46,9 @@
         {
             auto rawValue = static_cast<uint8_t>(
                 round(effecterValue - pdr->offset) / pdr->resolution);
-            if (pdr->min_set_table.value_u8 < pdr->max_set_table.value_u8 &&
-                (rawValue < pdr->min_set_table.value_u8 ||
-                 rawValue > pdr->max_set_table.value_u8))
+            if (pdr->min_settable.value_u8 < pdr->max_settable.value_u8 &&
+                (rawValue < pdr->min_settable.value_u8 ||
+                 rawValue > pdr->max_settable.value_u8))
             {
                 rc = PLDM_ERROR_INVALID_DATA;
             }
@@ -69,9 +69,9 @@
         {
             auto rawValue = static_cast<int8_t>(
                 round(effecterValue - pdr->offset) / pdr->resolution);
-            if (pdr->min_set_table.value_s8 < pdr->max_set_table.value_s8 &&
-                (rawValue < pdr->min_set_table.value_s8 ||
-                 rawValue > pdr->max_set_table.value_s8))
+            if (pdr->min_settable.value_s8 < pdr->max_settable.value_s8 &&
+                (rawValue < pdr->min_settable.value_s8 ||
+                 rawValue > pdr->max_settable.value_s8))
             {
                 rc = PLDM_ERROR_INVALID_DATA;
             }
@@ -82,9 +82,9 @@
         {
             auto rawValue = static_cast<uint16_t>(
                 round(effecterValue - pdr->offset) / pdr->resolution);
-            if (pdr->min_set_table.value_u16 < pdr->max_set_table.value_u16 &&
-                (rawValue < pdr->min_set_table.value_u16 ||
-                 rawValue > pdr->max_set_table.value_u16))
+            if (pdr->min_settable.value_u16 < pdr->max_settable.value_u16 &&
+                (rawValue < pdr->min_settable.value_u16 ||
+                 rawValue > pdr->max_settable.value_u16))
             {
                 rc = PLDM_ERROR_INVALID_DATA;
             }
@@ -105,9 +105,9 @@
         {
             auto rawValue = static_cast<int16_t>(
                 round(effecterValue - pdr->offset) / pdr->resolution);
-            if (pdr->min_set_table.value_s16 < pdr->max_set_table.value_s16 &&
-                (rawValue < pdr->min_set_table.value_s16 ||
-                 rawValue > pdr->max_set_table.value_s16))
+            if (pdr->min_settable.value_s16 < pdr->max_settable.value_s16 &&
+                (rawValue < pdr->min_settable.value_s16 ||
+                 rawValue > pdr->max_settable.value_s16))
             {
                 rc = PLDM_ERROR_INVALID_DATA;
             }
@@ -128,9 +128,9 @@
         {
             auto rawValue = static_cast<uint32_t>(
                 round(effecterValue - pdr->offset) / pdr->resolution);
-            if (pdr->min_set_table.value_u32 < pdr->max_set_table.value_u32 &&
-                (rawValue < pdr->min_set_table.value_u32 ||
-                 rawValue > pdr->max_set_table.value_u32))
+            if (pdr->min_settable.value_u32 < pdr->max_settable.value_u32 &&
+                (rawValue < pdr->min_settable.value_u32 ||
+                 rawValue > pdr->max_settable.value_u32))
             {
                 rc = PLDM_ERROR_INVALID_DATA;
             }
@@ -151,9 +151,9 @@
         {
             auto rawValue = static_cast<int32_t>(
                 round(effecterValue - pdr->offset) / pdr->resolution);
-            if (pdr->min_set_table.value_s32 < pdr->max_set_table.value_s32 &&
-                (rawValue < pdr->min_set_table.value_s32 ||
-                 rawValue > pdr->max_set_table.value_s32))
+            if (pdr->min_settable.value_s32 < pdr->max_settable.value_s32 &&
+                (rawValue < pdr->min_settable.value_s32 ||
+                 rawValue > pdr->max_settable.value_s32))
             {
                 rc = PLDM_ERROR_INVALID_DATA;
             }
diff --git a/pldmtool/pldm_platform_cmd.cpp b/pldmtool/pldm_platform_cmd.cpp
index a0e5ac2..694f333 100644
--- a/pldmtool/pldm_platform_cmd.cpp
+++ b/pldmtool/pldm_platform_cmd.cpp
@@ -832,28 +832,28 @@
         switch (pdr->effecter_data_size)
         {
             case PLDM_EFFECTER_DATA_SIZE_UINT8:
-                output["maxSettable"] = unsigned(pdr->max_set_table.value_u8);
-                output["minSettable"] = unsigned(pdr->min_set_table.value_u8);
+                output["maxSettable"] = unsigned(pdr->max_settable.value_u8);
+                output["minSettable"] = unsigned(pdr->min_settable.value_u8);
                 break;
             case PLDM_EFFECTER_DATA_SIZE_SINT8:
-                output["maxSettable"] = unsigned(pdr->max_set_table.value_s8);
-                output["minSettable"] = unsigned(pdr->min_set_table.value_s8);
+                output["maxSettable"] = unsigned(pdr->max_settable.value_s8);
+                output["minSettable"] = unsigned(pdr->min_settable.value_s8);
                 break;
             case PLDM_EFFECTER_DATA_SIZE_UINT16:
-                output["maxSettable"] = unsigned(pdr->max_set_table.value_u16);
-                output["minSettable"] = unsigned(pdr->min_set_table.value_u16);
+                output["maxSettable"] = unsigned(pdr->max_settable.value_u16);
+                output["minSettable"] = unsigned(pdr->min_settable.value_u16);
                 break;
             case PLDM_EFFECTER_DATA_SIZE_SINT16:
-                output["maxSettable"] = unsigned(pdr->max_set_table.value_s16);
-                output["minSettable"] = unsigned(pdr->min_set_table.value_s16);
+                output["maxSettable"] = unsigned(pdr->max_settable.value_s16);
+                output["minSettable"] = unsigned(pdr->min_settable.value_s16);
                 break;
             case PLDM_EFFECTER_DATA_SIZE_UINT32:
-                output["maxSettable"] = unsigned(pdr->max_set_table.value_u32);
-                output["minSettable"] = unsigned(pdr->min_set_table.value_u32);
+                output["maxSettable"] = unsigned(pdr->max_settable.value_u32);
+                output["minSettable"] = unsigned(pdr->min_settable.value_u32);
                 break;
             case PLDM_EFFECTER_DATA_SIZE_SINT32:
-                output["maxSettable"] = unsigned(pdr->max_set_table.value_s32);
-                output["minSettable"] = unsigned(pdr->min_set_table.value_s32);
+                output["maxSettable"] = unsigned(pdr->max_settable.value_s32);
+                output["minSettable"] = unsigned(pdr->min_settable.value_s32);
                 break;
             default:
                 break;