diff --git a/src/firmware_update.c b/src/firmware_update.c
index c5a213f..91fbb33 100644
--- a/src/firmware_update.c
+++ b/src/firmware_update.c
@@ -33,7 +33,6 @@
 static uint16_t get_descriptor_type_length(uint16_t descriptor_type)
 {
 	switch (descriptor_type) {
-
 	case PLDM_FWUP_PCI_VENDOR_ID:
 		return PLDM_FWUP_PCI_VENDOR_ID_LENGTH;
 	case PLDM_FWUP_IANA_ENTERPRISE_ID:
@@ -112,9 +111,9 @@
 
 	default:
 		if (comp_resp_code >=
-			PLDM_CRC_VENDOR_COMP_RESP_CODE_RANGE_MIN &&
+			    PLDM_CRC_VENDOR_COMP_RESP_CODE_RANGE_MIN &&
 		    comp_resp_code <=
-			PLDM_CRC_VENDOR_COMP_RESP_CODE_RANGE_MAX) {
+			    PLDM_CRC_VENDOR_COMP_RESP_CODE_RANGE_MAX) {
 			return true;
 		}
 		return false;
@@ -161,9 +160,9 @@
 
 	default:
 		if (comp_compatibility_resp_code >=
-			PLDM_CCRC_VENDOR_COMP_RESP_CODE_RANGE_MIN &&
+			    PLDM_CCRC_VENDOR_COMP_RESP_CODE_RANGE_MIN &&
 		    comp_compatibility_resp_code <=
-			PLDM_CCRC_VENDOR_COMP_RESP_CODE_RANGE_MAX) {
+			    PLDM_CCRC_VENDOR_COMP_RESP_CODE_RANGE_MAX) {
 			return true;
 		}
 		return false;
@@ -260,7 +259,6 @@
  */
 static bool is_reason_code_valid(uint8_t reason_code)
 {
-
 	switch (reason_code) {
 	case PLDM_FD_INITIALIZATION:
 	case PLDM_FD_ACTIVATE_FW:
@@ -286,7 +284,7 @@
  *  @return true if non functioning component indication is valid, false if not
  */
 static bool is_non_functioning_component_indication_valid(
-    bool8_t non_functioning_component_indication)
+	bool8_t non_functioning_component_indication)
 {
 	switch (non_functioning_component_indication) {
 	case PLDM_FWUP_COMPONENTS_FUNCTIONING:
@@ -299,9 +297,9 @@
 }
 
 int decode_pldm_package_header_info(
-    const uint8_t *data, size_t length,
-    struct pldm_package_header_information *package_header_info,
-    struct variable_field *package_version_str)
+	const uint8_t *data, size_t length,
+	struct pldm_package_header_information *package_header_info,
+	struct variable_field *package_version_str)
 {
 	if (data == NULL || package_header_info == NULL ||
 	    package_version_str == NULL) {
@@ -313,7 +311,7 @@
 	}
 
 	struct pldm_package_header_information *data_header =
-	    (struct pldm_package_header_information *)(data);
+		(struct pldm_package_header_information *)(data);
 
 	if (!is_string_type_valid(data_header->package_version_string_type) ||
 	    (data_header->package_version_string_length == 0)) {
@@ -321,7 +319,7 @@
 	}
 
 	if (length < sizeof(struct pldm_package_header_information) +
-			 data_header->package_version_string_length) {
+			     data_header->package_version_string_length) {
 		return PLDM_ERROR_INVALID_LENGTH;
 	}
 
@@ -333,33 +331,34 @@
 	memcpy(package_header_info->uuid, data_header->uuid,
 	       sizeof(data_header->uuid));
 	package_header_info->package_header_format_version =
-	    data_header->package_header_format_version;
+		data_header->package_header_format_version;
 	package_header_info->package_header_size =
-	    le16toh(data_header->package_header_size);
+		le16toh(data_header->package_header_size);
 	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);
+		le16toh(data_header->component_bitmap_bit_length);
 	package_header_info->package_version_string_type =
-	    data_header->package_version_string_type;
+		data_header->package_version_string_type;
 	package_header_info->package_version_string_length =
-	    data_header->package_version_string_length;
+		data_header->package_version_string_length;
 	package_version_str->ptr =
-	    data + sizeof(struct pldm_package_header_information);
+		data + sizeof(struct pldm_package_header_information);
 	package_version_str->length =
-	    package_header_info->package_version_string_length;
+		package_header_info->package_version_string_length;
 
 	return PLDM_SUCCESS;
 }
 
 int decode_firmware_device_id_record(
-    const uint8_t *data, size_t length, uint16_t component_bitmap_bit_length,
-    struct pldm_firmware_device_id_record *fw_device_id_record,
-    struct variable_field *applicable_components,
-    struct variable_field *comp_image_set_version_str,
-    struct variable_field *record_descriptors,
-    struct variable_field *fw_device_pkg_data)
+	const uint8_t *data, size_t length,
+	uint16_t component_bitmap_bit_length,
+	struct pldm_firmware_device_id_record *fw_device_id_record,
+	struct variable_field *applicable_components,
+	struct variable_field *comp_image_set_version_str,
+	struct variable_field *record_descriptors,
+	struct variable_field *fw_device_pkg_data)
 {
 	if (data == NULL || fw_device_id_record == NULL ||
 	    applicable_components == NULL ||
@@ -378,66 +377,67 @@
 	}
 
 	struct pldm_firmware_device_id_record *data_record =
-	    (struct pldm_firmware_device_id_record *)(data);
+		(struct pldm_firmware_device_id_record *)(data);
 
 	if (!is_string_type_valid(
-		data_record->comp_image_set_version_string_type) ||
+		    data_record->comp_image_set_version_string_type) ||
 	    (data_record->comp_image_set_version_string_length == 0)) {
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
 	fw_device_id_record->record_length =
-	    le16toh(data_record->record_length);
+		le16toh(data_record->record_length);
 	fw_device_id_record->descriptor_count = data_record->descriptor_count;
 	fw_device_id_record->device_update_option_flags.value =
-	    le32toh(data_record->device_update_option_flags.value);
+		le32toh(data_record->device_update_option_flags.value);
 	fw_device_id_record->comp_image_set_version_string_type =
-	    data_record->comp_image_set_version_string_type;
+		data_record->comp_image_set_version_string_type;
 	fw_device_id_record->comp_image_set_version_string_length =
-	    data_record->comp_image_set_version_string_length;
+		data_record->comp_image_set_version_string_length;
 	fw_device_id_record->fw_device_pkg_data_length =
-	    le16toh(data_record->fw_device_pkg_data_length);
+		le16toh(data_record->fw_device_pkg_data_length);
 
 	if (length < fw_device_id_record->record_length) {
 		return PLDM_ERROR_INVALID_LENGTH;
 	}
 
 	uint16_t applicable_components_length =
-	    component_bitmap_bit_length / PLDM_FWUP_COMPONENT_BITMAP_MULTIPLE;
+		component_bitmap_bit_length /
+		PLDM_FWUP_COMPONENT_BITMAP_MULTIPLE;
 	uint16_t calc_min_record_length =
-	    sizeof(struct pldm_firmware_device_id_record) +
-	    applicable_components_length +
-	    data_record->comp_image_set_version_string_length +
-	    PLDM_FWUP_DEVICE_DESCRIPTOR_MIN_LEN +
-	    fw_device_id_record->fw_device_pkg_data_length;
+		sizeof(struct pldm_firmware_device_id_record) +
+		applicable_components_length +
+		data_record->comp_image_set_version_string_length +
+		PLDM_FWUP_DEVICE_DESCRIPTOR_MIN_LEN +
+		fw_device_id_record->fw_device_pkg_data_length;
 
 	if (fw_device_id_record->record_length < calc_min_record_length) {
 		return PLDM_ERROR_INVALID_LENGTH;
 	}
 
 	applicable_components->ptr =
-	    data + sizeof(struct pldm_firmware_device_id_record);
+		data + sizeof(struct pldm_firmware_device_id_record);
 	applicable_components->length = applicable_components_length;
 
 	comp_image_set_version_str->ptr =
-	    applicable_components->ptr + applicable_components->length;
+		applicable_components->ptr + applicable_components->length;
 	comp_image_set_version_str->length =
-	    fw_device_id_record->comp_image_set_version_string_length;
+		fw_device_id_record->comp_image_set_version_string_length;
 
 	record_descriptors->ptr = comp_image_set_version_str->ptr +
 				  comp_image_set_version_str->length;
 	record_descriptors->length =
-	    fw_device_id_record->record_length -
-	    sizeof(struct pldm_firmware_device_id_record) -
-	    applicable_components_length -
-	    fw_device_id_record->comp_image_set_version_string_length -
-	    fw_device_id_record->fw_device_pkg_data_length;
+		fw_device_id_record->record_length -
+		sizeof(struct pldm_firmware_device_id_record) -
+		applicable_components_length -
+		fw_device_id_record->comp_image_set_version_string_length -
+		fw_device_id_record->fw_device_pkg_data_length;
 
 	if (fw_device_id_record->fw_device_pkg_data_length) {
 		fw_device_pkg_data->ptr =
-		    record_descriptors->ptr + record_descriptors->length;
+			record_descriptors->ptr + record_descriptors->length;
 		fw_device_pkg_data->length =
-		    fw_device_id_record->fw_device_pkg_data_length;
+			fw_device_id_record->fw_device_pkg_data_length;
 	}
 
 	return PLDM_SUCCESS;
@@ -459,7 +459,7 @@
 	}
 
 	struct pldm_descriptor_tlv *entry =
-	    (struct pldm_descriptor_tlv *)(data);
+		(struct pldm_descriptor_tlv *)(data);
 
 	*descriptor_type = le16toh(entry->descriptor_type);
 	descriptor_length = le16toh(entry->descriptor_length);
@@ -482,9 +482,9 @@
 }
 
 int decode_vendor_defined_descriptor_value(
-    const uint8_t *data, size_t length, uint8_t *descriptor_title_str_type,
-    struct variable_field *descriptor_title_str,
-    struct variable_field *descriptor_data)
+	const uint8_t *data, size_t length, uint8_t *descriptor_title_str_type,
+	struct variable_field *descriptor_title_str,
+	struct variable_field *descriptor_data)
 {
 	if (data == NULL || descriptor_title_str_type == NULL ||
 	    descriptor_title_str == NULL || descriptor_data == NULL) {
@@ -496,9 +496,9 @@
 	}
 
 	struct pldm_vendor_defined_descriptor_title_data *entry =
-	    (struct pldm_vendor_defined_descriptor_title_data *)(data);
+		(struct pldm_vendor_defined_descriptor_title_data *)(data);
 	if (!is_string_type_valid(
-		entry->vendor_defined_descriptor_title_str_type) ||
+		    entry->vendor_defined_descriptor_title_str_type) ||
 	    (entry->vendor_defined_descriptor_title_str_len == 0)) {
 		return PLDM_ERROR_INVALID_DATA;
 	}
@@ -510,25 +510,26 @@
 	}
 
 	*descriptor_title_str_type =
-	    entry->vendor_defined_descriptor_title_str_type;
+		entry->vendor_defined_descriptor_title_str_type;
 	descriptor_title_str->ptr = entry->vendor_defined_descriptor_title_str;
 	descriptor_title_str->length =
-	    entry->vendor_defined_descriptor_title_str_len;
+		entry->vendor_defined_descriptor_title_str_len;
 
 	descriptor_data->ptr =
-	    descriptor_title_str->ptr + descriptor_title_str->length;
+		descriptor_title_str->ptr + descriptor_title_str->length;
 	descriptor_data->length =
-	    length - sizeof(entry->vendor_defined_descriptor_title_str_type) -
-	    sizeof(entry->vendor_defined_descriptor_title_str_len) -
-	    descriptor_title_str->length;
+		length -
+		sizeof(entry->vendor_defined_descriptor_title_str_type) -
+		sizeof(entry->vendor_defined_descriptor_title_str_len) -
+		descriptor_title_str->length;
 
 	return PLDM_SUCCESS;
 }
 
 int decode_pldm_comp_image_info(
-    const uint8_t *data, size_t length,
-    struct pldm_component_image_information *pldm_comp_image_info,
-    struct variable_field *comp_version_str)
+	const uint8_t *data, size_t length,
+	struct pldm_component_image_information *pldm_comp_image_info,
+	struct variable_field *comp_version_str)
 {
 	if (data == NULL || pldm_comp_image_info == NULL ||
 	    comp_version_str == NULL) {
@@ -540,7 +541,7 @@
 	}
 
 	struct pldm_component_image_information *data_header =
-	    (struct pldm_component_image_information *)(data);
+		(struct pldm_component_image_information *)(data);
 
 	if (!is_string_type_valid(data_header->comp_version_string_type) ||
 	    (data_header->comp_version_string_length == 0)) {
@@ -548,31 +549,31 @@
 	}
 
 	if (length < sizeof(struct pldm_component_image_information) +
-			 data_header->comp_version_string_length) {
+			     data_header->comp_version_string_length) {
 		return PLDM_ERROR_INVALID_LENGTH;
 	}
 
 	pldm_comp_image_info->comp_classification =
-	    le16toh(data_header->comp_classification);
+		le16toh(data_header->comp_classification);
 	pldm_comp_image_info->comp_identifier =
-	    le16toh(data_header->comp_identifier);
+		le16toh(data_header->comp_identifier);
 	pldm_comp_image_info->comp_comparison_stamp =
-	    le32toh(data_header->comp_comparison_stamp);
+		le32toh(data_header->comp_comparison_stamp);
 	pldm_comp_image_info->comp_options.value =
-	    le16toh(data_header->comp_options.value);
+		le16toh(data_header->comp_options.value);
 	pldm_comp_image_info->requested_comp_activation_method.value =
-	    le16toh(data_header->requested_comp_activation_method.value);
+		le16toh(data_header->requested_comp_activation_method.value);
 	pldm_comp_image_info->comp_location_offset =
-	    le32toh(data_header->comp_location_offset);
+		le32toh(data_header->comp_location_offset);
 	pldm_comp_image_info->comp_size = le32toh(data_header->comp_size);
 	pldm_comp_image_info->comp_version_string_type =
-	    data_header->comp_version_string_type;
+		data_header->comp_version_string_type;
 	pldm_comp_image_info->comp_version_string_length =
-	    data_header->comp_version_string_length;
+		data_header->comp_version_string_length;
 
 	if ((pldm_comp_image_info->comp_options.bits.bit1 == false &&
 	     pldm_comp_image_info->comp_comparison_stamp !=
-		 PLDM_FWUP_INVALID_COMPONENT_COMPARISON_TIMESTAMP)) {
+		     PLDM_FWUP_INVALID_COMPONENT_COMPARISON_TIMESTAMP)) {
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
@@ -582,9 +583,9 @@
 	}
 
 	comp_version_str->ptr =
-	    data + sizeof(struct pldm_component_image_information);
+		data + sizeof(struct pldm_component_image_information);
 	comp_version_str->length =
-	    pldm_comp_image_info->comp_version_string_length;
+		pldm_comp_image_info->comp_version_string_length;
 
 	return PLDM_SUCCESS;
 }
@@ -629,7 +630,7 @@
 	}
 
 	struct pldm_query_device_identifiers_resp *response =
-	    (struct pldm_query_device_identifiers_resp *)msg->payload;
+		(struct pldm_query_device_identifiers_resp *)msg->payload;
 	*device_identifiers_len = le32toh(response->device_identifiers_len);
 
 	if (*device_identifiers_len < PLDM_FWUP_DEVICE_DESCRIPTOR_MIN_LEN) {
@@ -638,7 +639,7 @@
 
 	if (payload_length !=
 	    sizeof(struct pldm_query_device_identifiers_resp) +
-		*device_identifiers_len) {
+		    *device_identifiers_len) {
 		return PLDM_ERROR_INVALID_LENGTH;
 	}
 	*descriptor_count = response->descriptor_count;
@@ -647,8 +648,8 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 	*descriptor_data =
-	    (uint8_t *)(msg->payload +
-			sizeof(struct pldm_query_device_identifiers_resp));
+		(uint8_t *)(msg->payload +
+			    sizeof(struct pldm_query_device_identifiers_resp));
 	return PLDM_SUCCESS;
 }
 
@@ -669,11 +670,11 @@
 }
 
 int decode_get_firmware_parameters_resp(
-    const struct pldm_msg *msg, size_t payload_length,
-    struct pldm_get_firmware_parameters_resp *resp_data,
-    struct variable_field *active_comp_image_set_ver_str,
-    struct variable_field *pending_comp_image_set_ver_str,
-    struct variable_field *comp_parameter_table)
+	const struct pldm_msg *msg, size_t payload_length,
+	struct pldm_get_firmware_parameters_resp *resp_data,
+	struct variable_field *active_comp_image_set_ver_str,
+	struct variable_field *pending_comp_image_set_ver_str,
+	struct variable_field *comp_parameter_table)
 {
 	if (msg == NULL || resp_data == NULL ||
 	    active_comp_image_set_ver_str == NULL ||
@@ -692,10 +693,10 @@
 	}
 
 	struct pldm_get_firmware_parameters_resp *response =
-	    (struct pldm_get_firmware_parameters_resp *)msg->payload;
+		(struct pldm_get_firmware_parameters_resp *)msg->payload;
 
 	if (!is_string_type_valid(
-		response->active_comp_image_set_ver_str_type) ||
+		    response->active_comp_image_set_ver_str_type) ||
 	    (response->active_comp_image_set_ver_str_len == 0)) {
 		return PLDM_ERROR_INVALID_DATA;
 	}
@@ -707,44 +708,44 @@
 		}
 	} else {
 		if (!is_string_type_valid(
-			response->pending_comp_image_set_ver_str_type)) {
+			    response->pending_comp_image_set_ver_str_type)) {
 			return PLDM_ERROR_INVALID_DATA;
 		}
 	}
 
 	size_t partial_response_length =
-	    sizeof(struct pldm_get_firmware_parameters_resp) +
-	    response->active_comp_image_set_ver_str_len +
-	    response->pending_comp_image_set_ver_str_len;
+		sizeof(struct pldm_get_firmware_parameters_resp) +
+		response->active_comp_image_set_ver_str_len +
+		response->pending_comp_image_set_ver_str_len;
 
 	if (payload_length < partial_response_length) {
 		return PLDM_ERROR_INVALID_LENGTH;
 	}
 
 	resp_data->capabilities_during_update.value =
-	    le32toh(response->capabilities_during_update.value);
+		le32toh(response->capabilities_during_update.value);
 	resp_data->comp_count = le16toh(response->comp_count);
 	resp_data->active_comp_image_set_ver_str_type =
-	    response->active_comp_image_set_ver_str_type;
+		response->active_comp_image_set_ver_str_type;
 	resp_data->active_comp_image_set_ver_str_len =
-	    response->active_comp_image_set_ver_str_len;
+		response->active_comp_image_set_ver_str_len;
 	resp_data->pending_comp_image_set_ver_str_type =
-	    response->pending_comp_image_set_ver_str_type;
+		response->pending_comp_image_set_ver_str_type;
 	resp_data->pending_comp_image_set_ver_str_len =
-	    response->pending_comp_image_set_ver_str_len;
+		response->pending_comp_image_set_ver_str_len;
 
 	active_comp_image_set_ver_str->ptr =
-	    msg->payload + sizeof(struct pldm_get_firmware_parameters_resp);
+		msg->payload + sizeof(struct pldm_get_firmware_parameters_resp);
 	active_comp_image_set_ver_str->length =
-	    resp_data->active_comp_image_set_ver_str_len;
+		resp_data->active_comp_image_set_ver_str_len;
 
 	if (resp_data->pending_comp_image_set_ver_str_len != 0) {
 		pending_comp_image_set_ver_str->ptr =
-		    msg->payload +
-		    sizeof(struct pldm_get_firmware_parameters_resp) +
-		    resp_data->active_comp_image_set_ver_str_len;
+			msg->payload +
+			sizeof(struct pldm_get_firmware_parameters_resp) +
+			resp_data->active_comp_image_set_ver_str_len;
 		pending_comp_image_set_ver_str->length =
-		    resp_data->pending_comp_image_set_ver_str_len;
+			resp_data->pending_comp_image_set_ver_str_len;
 	} else {
 		pending_comp_image_set_ver_str->ptr = NULL;
 		pending_comp_image_set_ver_str->length = 0;
@@ -752,12 +753,12 @@
 
 	if (payload_length > partial_response_length && resp_data->comp_count) {
 		comp_parameter_table->ptr =
-		    msg->payload +
-		    sizeof(struct pldm_get_firmware_parameters_resp) +
-		    resp_data->active_comp_image_set_ver_str_len +
-		    resp_data->pending_comp_image_set_ver_str_len;
+			msg->payload +
+			sizeof(struct pldm_get_firmware_parameters_resp) +
+			resp_data->active_comp_image_set_ver_str_len +
+			resp_data->pending_comp_image_set_ver_str_len;
 		comp_parameter_table->length =
-		    payload_length - partial_response_length;
+			payload_length - partial_response_length;
 	} else {
 		comp_parameter_table->ptr = NULL;
 		comp_parameter_table->length = 0;
@@ -767,10 +768,10 @@
 }
 
 int decode_get_firmware_parameters_resp_comp_entry(
-    const uint8_t *data, size_t length,
-    struct pldm_component_parameter_entry *component_data,
-    struct variable_field *active_comp_ver_str,
-    struct variable_field *pending_comp_ver_str)
+	const uint8_t *data, size_t length,
+	struct pldm_component_parameter_entry *component_data,
+	struct variable_field *active_comp_ver_str,
+	struct variable_field *pending_comp_ver_str)
 {
 	if (data == NULL || component_data == NULL ||
 	    active_comp_ver_str == NULL || pending_comp_ver_str == NULL) {
@@ -782,7 +783,7 @@
 	}
 
 	struct pldm_component_parameter_entry *entry =
-	    (struct pldm_component_parameter_entry *)(data);
+		(struct pldm_component_parameter_entry *)(data);
 
 	size_t entry_length = sizeof(struct pldm_component_parameter_entry) +
 			      entry->active_comp_ver_str_len +
@@ -793,36 +794,36 @@
 	}
 
 	component_data->comp_classification =
-	    le16toh(entry->comp_classification);
+		le16toh(entry->comp_classification);
 	component_data->comp_identifier = le16toh(entry->comp_identifier);
 	component_data->comp_classification_index =
-	    entry->comp_classification_index;
+		entry->comp_classification_index;
 	component_data->active_comp_comparison_stamp =
-	    le32toh(entry->active_comp_comparison_stamp);
+		le32toh(entry->active_comp_comparison_stamp);
 	component_data->active_comp_ver_str_type =
-	    entry->active_comp_ver_str_type;
+		entry->active_comp_ver_str_type;
 	component_data->active_comp_ver_str_len =
-	    entry->active_comp_ver_str_len;
+		entry->active_comp_ver_str_len;
 	memcpy(component_data->active_comp_release_date,
 	       entry->active_comp_release_date,
 	       sizeof(entry->active_comp_release_date));
 	component_data->pending_comp_comparison_stamp =
-	    le32toh(entry->pending_comp_comparison_stamp);
+		le32toh(entry->pending_comp_comparison_stamp);
 	component_data->pending_comp_ver_str_type =
-	    entry->pending_comp_ver_str_type;
+		entry->pending_comp_ver_str_type;
 	component_data->pending_comp_ver_str_len =
-	    entry->pending_comp_ver_str_len;
+		entry->pending_comp_ver_str_len;
 	memcpy(component_data->pending_comp_release_date,
 	       entry->pending_comp_release_date,
 	       sizeof(entry->pending_comp_release_date));
 	component_data->comp_activation_methods.value =
-	    le16toh(entry->comp_activation_methods.value);
+		le16toh(entry->comp_activation_methods.value);
 	component_data->capabilities_during_update.value =
-	    le32toh(entry->capabilities_during_update.value);
+		le32toh(entry->capabilities_during_update.value);
 
 	if (entry->active_comp_ver_str_len != 0) {
 		active_comp_ver_str->ptr =
-		    data + sizeof(struct pldm_component_parameter_entry);
+			data + sizeof(struct pldm_component_parameter_entry);
 		active_comp_ver_str->length = entry->active_comp_ver_str_len;
 	} else {
 		active_comp_ver_str->ptr = NULL;
@@ -830,10 +831,9 @@
 	}
 
 	if (entry->pending_comp_ver_str_len != 0) {
-
 		pending_comp_ver_str->ptr =
-		    data + sizeof(struct pldm_component_parameter_entry) +
-		    entry->active_comp_ver_str_len;
+			data + sizeof(struct pldm_component_parameter_entry) +
+			entry->active_comp_ver_str_len;
 		pending_comp_ver_str->length = entry->pending_comp_ver_str_len;
 	} else {
 		pending_comp_ver_str->ptr = NULL;
@@ -857,7 +857,7 @@
 	}
 
 	if (payload_length != sizeof(struct pldm_request_update_req) +
-				  comp_img_set_ver_str->length) {
+				      comp_img_set_ver_str->length) {
 		return PLDM_ERROR_INVALID_LENGTH;
 	}
 
@@ -875,7 +875,7 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	struct pldm_header_info header = {0};
+	struct pldm_header_info header = { 0 };
 	header.instance = instance_id;
 	header.msg_type = PLDM_REQUEST;
 	header.pldm_type = PLDM_FWUP;
@@ -886,7 +886,7 @@
 	}
 
 	struct pldm_request_update_req *request =
-	    (struct pldm_request_update_req *)msg->payload;
+		(struct pldm_request_update_req *)msg->payload;
 
 	request->max_transfer_size = htole32(max_transfer_size);
 	request->num_of_comp = htole16(num_of_comp);
@@ -922,7 +922,7 @@
 	}
 
 	struct pldm_request_update_resp *response =
-	    (struct pldm_request_update_resp *)msg->payload;
+		(struct pldm_request_update_resp *)msg->payload;
 
 	*fd_meta_data_len = le16toh(response->fd_meta_data_len);
 	*fd_will_send_pkg_data = response->fd_will_send_pkg_data;
@@ -930,19 +930,22 @@
 	return PLDM_SUCCESS;
 }
 
-int encode_pass_component_table_req(
-    uint8_t instance_id, uint8_t transfer_flag, uint16_t comp_classification,
-    uint16_t comp_identifier, uint8_t comp_classification_index,
-    uint32_t comp_comparison_stamp, uint8_t comp_ver_str_type,
-    uint8_t comp_ver_str_len, const struct variable_field *comp_ver_str,
-    struct pldm_msg *msg, size_t payload_length)
+int encode_pass_component_table_req(uint8_t instance_id, uint8_t transfer_flag,
+				    uint16_t comp_classification,
+				    uint16_t comp_identifier,
+				    uint8_t comp_classification_index,
+				    uint32_t comp_comparison_stamp,
+				    uint8_t comp_ver_str_type,
+				    uint8_t comp_ver_str_len,
+				    const struct variable_field *comp_ver_str,
+				    struct pldm_msg *msg, size_t payload_length)
 {
 	if (comp_ver_str == NULL || comp_ver_str->ptr == NULL || msg == NULL) {
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
 	if (payload_length != sizeof(struct pldm_pass_component_table_req) +
-				  comp_ver_str->length) {
+				      comp_ver_str->length) {
 		return PLDM_ERROR_INVALID_LENGTH;
 	}
 
@@ -959,7 +962,7 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	struct pldm_header_info header = {0};
+	struct pldm_header_info header = { 0 };
 	header.instance = instance_id;
 	header.msg_type = PLDM_REQUEST;
 	header.pldm_type = PLDM_FWUP;
@@ -970,7 +973,7 @@
 	}
 
 	struct pldm_pass_component_table_req *request =
-	    (struct pldm_pass_component_table_req *)msg->payload;
+		(struct pldm_pass_component_table_req *)msg->payload;
 
 	request->transfer_flag = transfer_flag;
 	request->comp_classification = htole16(comp_classification);
@@ -1007,7 +1010,7 @@
 	}
 
 	struct pldm_pass_component_table_resp *response =
-	    (struct pldm_pass_component_table_resp *)msg->payload;
+		(struct pldm_pass_component_table_resp *)msg->payload;
 
 	if (!is_comp_resp_valid(response->comp_resp)) {
 		return PLDM_ERROR_INVALID_DATA;
@@ -1024,12 +1027,12 @@
 }
 
 int encode_update_component_req(
-    uint8_t instance_id, uint16_t comp_classification, uint16_t comp_identifier,
-    uint8_t comp_classification_index, uint32_t comp_comparison_stamp,
-    uint32_t comp_image_size, bitfield32_t update_option_flags,
-    uint8_t comp_ver_str_type, uint8_t comp_ver_str_len,
-    const struct variable_field *comp_ver_str, struct pldm_msg *msg,
-    size_t payload_length)
+	uint8_t instance_id, uint16_t comp_classification,
+	uint16_t comp_identifier, uint8_t comp_classification_index,
+	uint32_t comp_comparison_stamp, uint32_t comp_image_size,
+	bitfield32_t update_option_flags, uint8_t comp_ver_str_type,
+	uint8_t comp_ver_str_len, const struct variable_field *comp_ver_str,
+	struct pldm_msg *msg, size_t payload_length)
 {
 	if (comp_ver_str == NULL || comp_ver_str->ptr == NULL || msg == NULL) {
 		return PLDM_ERROR_INVALID_DATA;
@@ -1053,7 +1056,7 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	struct pldm_header_info header = {0};
+	struct pldm_header_info header = { 0 };
 	header.instance = instance_id;
 	header.msg_type = PLDM_REQUEST;
 	header.pldm_type = PLDM_FWUP;
@@ -1064,7 +1067,7 @@
 	}
 
 	struct pldm_update_component_req *request =
-	    (struct pldm_update_component_req *)msg->payload;
+		(struct pldm_update_component_req *)msg->payload;
 
 	request->comp_classification = htole16(comp_classification);
 	request->comp_identifier = htole16(comp_identifier);
@@ -1107,22 +1110,22 @@
 	}
 
 	struct pldm_update_component_resp *response =
-	    (struct pldm_update_component_resp *)msg->payload;
+		(struct pldm_update_component_resp *)msg->payload;
 
 	if (!is_comp_compatibility_resp_valid(
-		response->comp_compatibility_resp)) {
+		    response->comp_compatibility_resp)) {
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
 	if (!is_comp_compatibility_resp_code_valid(
-		response->comp_compatibility_resp_code)) {
+		    response->comp_compatibility_resp_code)) {
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
 	*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);
+		le32toh(response->update_option_flags_enabled.value);
 	*time_before_req_fw_data = le16toh(response->time_before_req_fw_data);
 
 	return PLDM_SUCCESS;
@@ -1139,7 +1142,7 @@
 		return PLDM_ERROR_INVALID_LENGTH;
 	}
 	struct pldm_request_firmware_data_req *request =
-	    (struct pldm_request_firmware_data_req *)msg->payload;
+		(struct pldm_request_firmware_data_req *)msg->payload;
 	*offset = le32toh(request->offset);
 	*length = le32toh(request->length);
 
@@ -1159,7 +1162,7 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	struct pldm_header_info header = {0};
+	struct pldm_header_info header = { 0 };
 	header.instance = instance_id;
 	header.msg_type = PLDM_RESPONSE;
 	header.pldm_type = PLDM_FWUP;
@@ -1201,7 +1204,7 @@
 		return PLDM_ERROR_INVALID_LENGTH;
 	}
 
-	struct pldm_header_info header = {0};
+	struct pldm_header_info header = { 0 };
 	header.instance = instance_id;
 	header.msg_type = PLDM_RESPONSE;
 	header.pldm_type = PLDM_FWUP;
@@ -1242,7 +1245,7 @@
 		return PLDM_ERROR_INVALID_LENGTH;
 	}
 
-	struct pldm_header_info header = {0};
+	struct pldm_header_info header = { 0 };
 	header.instance = instance_id;
 	header.msg_type = PLDM_RESPONSE;
 	header.pldm_type = PLDM_FWUP;
@@ -1257,9 +1260,9 @@
 	return PLDM_SUCCESS;
 }
 
-int decode_apply_complete_req(
-    const struct pldm_msg *msg, size_t payload_length, uint8_t *apply_result,
-    bitfield16_t *comp_activation_methods_modification)
+int decode_apply_complete_req(const struct pldm_msg *msg, size_t payload_length,
+			      uint8_t *apply_result,
+			      bitfield16_t *comp_activation_methods_modification)
 {
 	if (msg == NULL || apply_result == NULL ||
 	    comp_activation_methods_modification == NULL) {
@@ -1271,11 +1274,11 @@
 	}
 
 	struct pldm_apply_complete_req *request =
-	    (struct pldm_apply_complete_req *)msg->payload;
+		(struct pldm_apply_complete_req *)msg->payload;
 
 	*apply_result = request->apply_result;
 	comp_activation_methods_modification->value =
-	    le16toh(request->comp_activation_methods_modification.value);
+		le16toh(request->comp_activation_methods_modification.value);
 
 	if ((*apply_result != PLDM_FWUP_APPLY_SUCCESS_WITH_ACTIVATION_METHOD) &&
 	    comp_activation_methods_modification->value) {
@@ -1296,7 +1299,7 @@
 		return PLDM_ERROR_INVALID_LENGTH;
 	}
 
-	struct pldm_header_info header = {0};
+	struct pldm_header_info header = { 0 };
 	header.instance = instance_id;
 	header.msg_type = PLDM_RESPONSE;
 	header.pldm_type = PLDM_FWUP;
@@ -1324,11 +1327,11 @@
 	}
 
 	if (!is_self_contained_activation_req_valid(
-		self_contained_activation_req)) {
+		    self_contained_activation_req)) {
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	struct pldm_header_info header = {0};
+	struct pldm_header_info header = { 0 };
 	header.instance = instance_id;
 	header.msg_type = PLDM_REQUEST;
 	header.pldm_type = PLDM_FWUP;
@@ -1339,7 +1342,7 @@
 	}
 
 	struct pldm_activate_firmware_req *request =
-	    (struct pldm_activate_firmware_req *)msg->payload;
+		(struct pldm_activate_firmware_req *)msg->payload;
 
 	request->self_contained_activation_req = self_contained_activation_req;
 
@@ -1366,10 +1369,10 @@
 	}
 
 	struct pldm_activate_firmware_resp *response =
-	    (struct pldm_activate_firmware_resp *)msg->payload;
+		(struct pldm_activate_firmware_resp *)msg->payload;
 
 	*estimated_time_activation =
-	    le16toh(response->estimated_time_activation);
+		le16toh(response->estimated_time_activation);
 
 	return PLDM_SUCCESS;
 }
@@ -1385,7 +1388,7 @@
 		return PLDM_ERROR_INVALID_LENGTH;
 	}
 
-	struct pldm_header_info header = {0};
+	struct pldm_header_info header = { 0 };
 	header.instance = instance_id;
 	header.msg_type = PLDM_REQUEST;
 	header.pldm_type = PLDM_FWUP;
@@ -1422,7 +1425,7 @@
 		return PLDM_ERROR_INVALID_LENGTH;
 	}
 	struct pldm_get_status_resp *response =
-	    (struct pldm_get_status_resp *)msg->payload;
+		(struct pldm_get_status_resp *)msg->payload;
 
 	if (!is_state_valid(response->current_state)) {
 		return PLDM_ERROR_INVALID_DATA;
@@ -1459,7 +1462,7 @@
 	*progress_percent = response->progress_percent;
 	*reason_code = response->reason_code;
 	update_option_flags_enabled->value =
-	    le32toh(response->update_option_flags_enabled.value);
+		le32toh(response->update_option_flags_enabled.value);
 
 	return PLDM_SUCCESS;
 }
@@ -1476,7 +1479,7 @@
 		return PLDM_ERROR_INVALID_LENGTH;
 	}
 
-	struct pldm_header_info header = {0};
+	struct pldm_header_info header = { 0 };
 	header.instance = instance_id;
 	header.msg_type = PLDM_REQUEST;
 	header.pldm_type = PLDM_FWUP;
@@ -1516,7 +1519,7 @@
 		return PLDM_ERROR_INVALID_LENGTH;
 	}
 
-	struct pldm_header_info header = {0};
+	struct pldm_header_info header = { 0 };
 	header.instance = instance_id;
 	header.msg_type = PLDM_REQUEST;
 	header.pldm_type = PLDM_FWUP;
@@ -1549,19 +1552,19 @@
 		return PLDM_ERROR_INVALID_LENGTH;
 	}
 	struct pldm_cancel_update_resp *response =
-	    (struct pldm_cancel_update_resp *)msg->payload;
+		(struct pldm_cancel_update_resp *)msg->payload;
 
 	if (!is_non_functioning_component_indication_valid(
-		response->non_functioning_component_indication)) {
+		    response->non_functioning_component_indication)) {
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
 	*non_functioning_component_indication =
-	    response->non_functioning_component_indication;
+		response->non_functioning_component_indication;
 
 	if (*non_functioning_component_indication) {
 		non_functioning_component_bitmap->value =
-		    le64toh(response->non_functioning_component_bitmap);
+			le64toh(response->non_functioning_component_bitmap);
 	}
 
 	return PLDM_SUCCESS;