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,
