Merge tag 'upstream/1.8.14'

Upstream version 1.8.14

1 files changed, 2624 insertions, 0 deletions

diff --git a/lib/ipmi_hpmfwupg.c b/lib/ipmi_hpmfwupg.c
new file mode 100644
index 0000000..69950b7
--- /dev/null
+++ b/lib/ipmi_hpmfwupg.c
@@ -0,0 +1,2624 @@
+/*
+ * Copyright (c) 2006 Kontron Canada, Inc.  All Rights Reserved.
+ * Copyright (c) 2003 Sun Microsystems, Inc.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * Redistribution of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * Redistribution in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * This software is provided "AS IS," without a warranty of any kind.
+ * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
+ * SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE
+ * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
+ * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.  IN NO EVENT WILL
+ * SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,
+ * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
+ * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
+ * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
+ * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#include <ipmitool/ipmi_intf.h>
+#include <ipmitool/ipmi_mc.h>
+#include <ipmitool/ipmi_hpmfwupg.h>
+#include <ipmitool/helper.h>
+#include <ipmitool/ipmi_strings.h>
+#include <ipmitool/log.h>
+#include "../src/plugins/lan/md5.h"
+#include <stdio.h>
+#include <time.h>
+#include <sys/param.h>
+
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+extern int verbose;
+
+int HpmfwupgUpgrade(struct ipmi_intf *intf, char *imageFilename,
+		int activate, int, int);
+int HpmfwupgValidateImageIntegrity(struct HpmfwupgUpgradeCtx *pFwupgCtx);
+int HpmfwupgPreparationStage(struct ipmi_intf *intf,
+		struct HpmfwupgUpgradeCtx *pFwupgCtx, int option);
+int HpmfwupgUpgradeStage(struct ipmi_intf *intf,
+		struct HpmfwupgUpgradeCtx *pFwupgCtx, int option);
+int HpmfwupgActivationStage(struct ipmi_intf *intf,
+		struct HpmfwupgUpgradeCtx *pFwupgCtx);
+int HpmfwupgGetTargetUpgCapabilities(struct ipmi_intf *intf,
+		struct HpmfwupgGetTargetUpgCapabilitiesCtx *pCtx);
+int HpmfwupgGetComponentProperties(struct ipmi_intf *intf,
+		struct HpmfwupgGetComponentPropertiesCtx *pCtx);
+int HpmfwupgQuerySelftestResult(struct ipmi_intf *intf,
+		struct HpmfwupgQuerySelftestResultCtx *pCtx,
+		struct HpmfwupgUpgradeCtx *pFwupgCtx);
+int HpmfwupgQueryRollbackStatus(struct ipmi_intf *intf,
+		struct HpmfwupgQueryRollbackStatusCtx *pCtx,
+		struct HpmfwupgUpgradeCtx *pFwupgCtx);
+int HpmfwupgAbortUpgrade(struct ipmi_intf *intf,
+		struct HpmfwupgAbortUpgradeCtx *pCtx);
+int HpmfwupgInitiateUpgradeAction(struct ipmi_intf *intf,
+		struct HpmfwupgInitiateUpgradeActionCtx *pCtx,
+		struct HpmfwupgUpgradeCtx *pFwupgCtx);
+int HpmfwupgUploadFirmwareBlock(struct ipmi_intf *intf,
+		struct HpmfwupgUploadFirmwareBlockCtx *pCtx,
+		struct HpmfwupgUpgradeCtx *pFwupgCtx, int count,
+		unsigned int *pOffset, unsigned int *blockLen);
+int HpmfwupgFinishFirmwareUpload(struct ipmi_intf *intf,
+		struct HpmfwupgFinishFirmwareUploadCtx *pCtx,
+		struct HpmfwupgUpgradeCtx *pFwupgCtx, int option);
+int HpmfwupgActivateFirmware(struct ipmi_intf *intf,
+		struct HpmfwupgActivateFirmwareCtx *pCtx,
+		struct HpmfwupgUpgradeCtx *pFwupgCtx);
+int HpmfwupgGetUpgradeStatus(struct ipmi_intf *intf,
+		struct HpmfwupgGetUpgradeStatusCtx *pCtxstruct,
+		struct HpmfwupgUpgradeCtx *pFwupgCtx, int silent);
+int HpmfwupgManualFirmwareRollback(struct ipmi_intf *intf,
+		struct HpmfwupgManualFirmwareRollbackCtx *pCtx);
+void HpmfwupgPrintUsage(void);
+unsigned char HpmfwupgCalculateChecksum(unsigned char *pData,
+		unsigned int length);
+int HpmfwupgGetDeviceId(struct ipmi_intf *intf,
+		struct ipm_devid_rsp *pGetDevId);
+int HpmfwupgGetBufferFromFile(char *imageFilename,
+		struct HpmfwupgUpgradeCtx *pFwupgCtx);
+int HpmfwupgWaitLongDurationCmd(struct ipmi_intf *intf,
+		struct HpmfwupgUpgradeCtx *pFwupgCtx);
+struct ipmi_rs *HpmfwupgSendCmd(struct ipmi_intf *intf,
+		struct ipmi_rq req, struct HpmfwupgUpgradeCtx* pFwupgCtx);
+
+
+int HpmFwupgActionUploadFirmware(struct HpmfwupgComponentBitMask components,
+		struct HpmfwupgUpgradeCtx* pFwupgCtx,
+		unsigned char **pImagePtr,
+		struct ipmi_intf *intf,
+		int option,
+		int *pFlagColdReset);
+
+/* HpmGetuserInput - get input from user
+ *
+ * returns TRUE if its Yes or FALSE if its No
+ */
+int
+HpmGetUserInput(char *str)
+{
+	char userInput[2];
+	int ret;
+
+	printf("%s", str);
+	ret = scanf("%s", userInput);
+	if (!ret) {
+		return 1;
+	}
+	if (toupper(userInput[0]) == 'Y') {
+		return 1;
+	}
+	return 0;
+}
+
+/* HpmDisplayLine - display the line with the given character
+ */
+void
+HpmDisplayLine(char *s, int n)
+{
+	while (n--) {
+		printf ("%c", *s);
+	}
+	printf("\n");
+}
+
+/* HpmDisplayUpgradeHeader - display the Upgrade header information
+ */
+void
+HpmDisplayUpgradeHeader(void)
+{
+	printf("\n");
+	HpmDisplayLine("-", 79);
+	printf(
+"|ID  | Name        |                     Versions                        | %%  |\n");
+	printf(
+"|    |             |      Active     |      Backup     |      File       |    |\n");
+	printf(
+"|----|-------------|-----------------|-----------------|-----------------|----|\n");
+}
+
+/* HpmDisplayUpgrade - display the progress of the upgrade; prints the "."
+ * for every 5% of its completion.
+ */
+void
+HpmDisplayUpgrade(int skip, unsigned int totalSent,
+		unsigned int displayFWLength, time_t timeElapsed)
+{
+	int percent;
+	static int old_percent = -1;
+	if (skip) {
+		printf("Skip|\n");
+		return;
+	}
+	fflush(stdout);
+
+	percent = ((float)totalSent / displayFWLength) * 100;
+	if (percent != old_percent) {
+		if (old_percent != -1) {
+			printf("\b\b\b\b\b");
+		}
+		printf("%3d%%|", percent);
+		old_percent = percent;
+	}
+	if (totalSent == displayFWLength) {
+		/* Display the time taken to complete the upgrade */
+		printf(
+"\n|    |Upload Time: %02ld:%02ld             | Image Size: %7d bytes              |\n",
+			timeElapsed / 60, timeElapsed % 60, totalSent);
+		old_percent = -1;
+	}
+}
+
+/* HpmDisplayVersionHeader - display the information about version header
+ */
+void
+HpmDisplayVersionHeader(int mode)
+{
+	if (mode & IMAGE_VER) {
+		HpmDisplayLine("-", 74);
+		printf(
+"|ID  | Name        |                     Versions                        |\n");
+		printf(
+"|    |             |     Active      |     Backup      |      File       |\n");
+		HpmDisplayLine("-", 74);
+	} else {
+		HpmDisplayLine("-",74 );
+		printf(
+"|ID  | Name        |                     Versions                        |\n");
+		printf(
+"|    |             |     Active      |     Backup      |      Deferred   |\n");
+		HpmDisplayLine("-", 74);
+	}
+}
+
+/* HpmDisplayVersion - display the version of the image and target
+ */
+void
+HpmDisplayVersion(int mode, VERSIONINFO *pVersion, int upgradable)
+{
+	/*
+	 * If the cold reset is required then we can display * on it
+	 * so that user is aware that he needs to do payload power
+	 * cycle after upgrade
+	 */
+	printf("|%c%c%2d|%-13s|",
+			pVersion->coldResetRequired ? '*' : ' ',
+			upgradable ? '^' : ' ',
+			pVersion->componentId, pVersion->descString);
+
+	if (mode & TARGET_VER) {
+		if ((pVersion->targetMajor == 0xFF
+					|| (pVersion->targetMajor == 0x7F))
+				&& pVersion->targetMinor == 0xFF) {
+			printf(" ---.-- -------- |");
+		} else {
+			printf(" %3d.%02x %02X%02X%02X%02X |",
+					pVersion->targetMajor,
+					pVersion->targetMinor,
+					pVersion->targetAux[0],
+					pVersion->targetAux[1],
+					pVersion->targetAux[2],
+					pVersion->targetAux[3]);
+		}
+		if (mode & ROLLBACK_VER) {
+			if ((pVersion->rollbackMajor == 0xFF
+						|| (pVersion->rollbackMajor == 0x7F))
+					&& pVersion->rollbackMinor == 0xFF) {
+				printf(" ---.-- -------- |");
+			} else {
+				printf(" %3d.%02x %02X%02X%02X%02X |",
+						pVersion->rollbackMajor,
+						pVersion->rollbackMinor,
+						pVersion->rollbackAux[0],
+						pVersion->rollbackAux[1],
+						pVersion->rollbackAux[2],
+						pVersion->rollbackAux[3]);
+			}
+		} else {
+			printf(" ---.-- -------- |");
+		}
+	}
+	if (mode & IMAGE_VER) {
+		if ((pVersion->imageMajor == 0xFF
+					|| (pVersion->imageMajor == 0x7F))
+				&& pVersion->imageMinor == 0xFF) {
+			printf(" ---.-- |");
+		} else {
+			printf(" %3d.%02x %02X%02X%02X%02X |",
+					pVersion->imageMajor,
+					pVersion->imageMinor,
+					pVersion->imageAux[0],
+					pVersion->imageAux[1],
+					pVersion->imageAux[2],
+					pVersion->imageAux[3]);
+		}
+	} else {
+		if ((pVersion->deferredMajor == 0xFF
+					|| (pVersion->deferredMajor == 0x7F))
+				&& pVersion->deferredMinor == 0xFF) {
+			printf(" ---.-- -------- |");
+		} else {
+			printf(" %3d.%02x %02X%02X%02X%02X |",
+					pVersion->deferredMajor,
+					pVersion->deferredMinor,
+					pVersion->deferredAux[0],
+					pVersion->deferredAux[1],
+					pVersion->deferredAux[2],
+					pVersion->deferredAux[3]);
+		}
+	}
+}
+
+/* HpmfwupgTargerCheck - get target information and displays it on the screen
+ */
+int
+HpmfwupgTargetCheck(struct ipmi_intf *intf, int option)
+{
+	struct HpmfwupgGetTargetUpgCapabilitiesCtx targetCapCmd;
+	int rc = HPMFWUPG_SUCCESS;
+	int componentId = 0;
+	int flagColdReset = FALSE;
+	struct ipm_devid_rsp devIdrsp;
+	struct HpmfwupgGetComponentPropertiesCtx getCompProp;
+	int mode = 0;
+	rc = HpmfwupgGetDeviceId(intf, &devIdrsp);
+	if (rc != HPMFWUPG_SUCCESS) {
+		lprintf(LOG_NOTICE,
+				"Verify whether the Target board is present \n");
+		return HPMFWUPG_ERROR;
+	}
+	rc = HpmfwupgGetTargetUpgCapabilities(intf, &targetCapCmd);
+	if (rc != HPMFWUPG_SUCCESS) {
+		/* That indicates the target is not responding to the command
+		 * May be that there is no HPM support
+		 */
+		lprintf(LOG_NOTICE,
+				"Board might not be supporting the HPM.1 Standards\n");
+		return rc;
+	}
+	if (option & VIEW_MODE) {
+		lprintf(LOG_NOTICE, "-------Target Information-------");
+		lprintf(LOG_NOTICE, "Device Id          : 0x%x",
+				devIdrsp.device_id);
+		lprintf(LOG_NOTICE, "Device Revision    : 0x%x",
+				devIdrsp.device_revision);
+		lprintf(LOG_NOTICE, "Product Id         : 0x%04x",
+				buf2short(devIdrsp.product_id));
+		lprintf(LOG_NOTICE, "Manufacturer Id    : 0x%04x (%s)\n\n",
+				buf2short(devIdrsp.manufacturer_id),
+				val2str(buf2short(devIdrsp.manufacturer_id),ipmi_oem_info));
+		HpmDisplayVersionHeader(TARGET_VER|ROLLBACK_VER);
+	}
+	for (componentId = HPMFWUPG_COMPONENT_ID_0;
+			componentId < HPMFWUPG_COMPONENT_ID_MAX;
+			componentId++ ) {
+		/* If the component is supported */
+		if (((1 << componentId) & targetCapCmd.resp.componentsPresent.ComponentBits.byte)) {
+			memset((PVERSIONINFO)&gVersionInfo[componentId], 0x00, sizeof(VERSIONINFO));
+			getCompProp.req.componentId = componentId;
+			getCompProp.req.selector = HPMFWUPG_COMP_GEN_PROPERTIES;
+			rc = HpmfwupgGetComponentProperties(intf, &getCompProp);
+			if (rc != HPMFWUPG_SUCCESS) {
+				lprintf(LOG_NOTICE, "Get CompGenProp Failed for component Id %d\n",
+						componentId);
+				return rc;
+			}
+			gVersionInfo[componentId].rollbackSupported = getCompProp.resp.Response.
+				generalPropResp.GeneralCompProperties.bitfield.rollbackBackup;
+			gVersionInfo[componentId].coldResetRequired =  getCompProp.resp.Response.
+				generalPropResp.GeneralCompProperties.bitfield.payloadColdReset;
+			getCompProp.req.selector = HPMFWUPG_COMP_DESCRIPTION_STRING;
+			rc = HpmfwupgGetComponentProperties(intf, &getCompProp);
+			if (rc != HPMFWUPG_SUCCESS) {
+				lprintf(LOG_NOTICE,
+						"Get CompDescString Failed for component Id %d\n",
+						componentId);
+				return rc;
+			}
+			memcpy(gVersionInfo[componentId].descString,
+					getCompProp.resp.Response.descStringResp.descString,
+					HPMFWUPG_DESC_STRING_LENGTH);
+			gVersionInfo[componentId].descString[HPMFWUPG_DESC_STRING_LENGTH] = '\0';
+			getCompProp.req.selector = HPMFWUPG_COMP_CURRENT_VERSION;
+			rc = HpmfwupgGetComponentProperties(intf, &getCompProp);
+			if (rc != HPMFWUPG_SUCCESS) {
+				lprintf(LOG_NOTICE,
+						"Get CompCurrentVersion Failed for component Id %d\n",
+						componentId);
+				return rc;
+			}
+			gVersionInfo[componentId].componentId = componentId;
+			gVersionInfo[componentId].targetMajor = getCompProp.resp.Response.
+				currentVersionResp.currentVersion[0];
+			gVersionInfo[componentId].targetMinor = getCompProp.resp.Response.
+				currentVersionResp.currentVersion[1];
+			gVersionInfo[componentId].targetAux[0] = getCompProp.resp.Response.
+				currentVersionResp.currentVersion[2];
+			gVersionInfo[componentId].targetAux[1] = getCompProp.resp.Response.
+				currentVersionResp.currentVersion[3];
+			gVersionInfo[componentId].targetAux[2] = getCompProp.resp.Response.
+				currentVersionResp.currentVersion[4];
+			gVersionInfo[componentId].targetAux[3] = getCompProp.resp.Response.
+				currentVersionResp.currentVersion[5];
+			mode = TARGET_VER;
+			if (gVersionInfo[componentId].rollbackSupported) {
+				getCompProp.req.selector = HPMFWUPG_COMP_ROLLBACK_FIRMWARE_VERSION;
+				rc = HpmfwupgGetComponentProperties(intf, &getCompProp);
+				if (rc != HPMFWUPG_SUCCESS) {
+					lprintf(LOG_NOTICE,
+							"Get CompRollbackVersion Failed for component Id %d\n",
+							componentId);
+				} else {
+					gVersionInfo[componentId].rollbackMajor = getCompProp.resp
+						.Response.rollbackFwVersionResp.rollbackFwVersion[0];
+					gVersionInfo[componentId].rollbackMinor = getCompProp.resp
+						.Response.rollbackFwVersionResp.rollbackFwVersion[1];
+					gVersionInfo[componentId].rollbackAux[0] = getCompProp.resp.Response.rollbackFwVersionResp.rollbackFwVersion[2];
+					gVersionInfo[componentId].rollbackAux[1] = getCompProp.resp.Response.rollbackFwVersionResp.rollbackFwVersion[3];
+					gVersionInfo[componentId].rollbackAux[2] = getCompProp.resp.Response.rollbackFwVersionResp.rollbackFwVersion[4];
+					gVersionInfo[componentId].rollbackAux[3] = getCompProp.resp.Response.rollbackFwVersionResp.rollbackFwVersion[5];
+				}
+				getCompProp.req.selector = HPMFWUPG_COMP_DEFERRED_FIRMWARE_VERSION;
+				rc = HpmfwupgGetComponentProperties(intf, &getCompProp);
+				if (rc != HPMFWUPG_SUCCESS) {
+					lprintf(LOG_NOTICE,
+							"Get CompRollbackVersion Failed for component Id %d\n",
+							componentId);
+				} else {
+					gVersionInfo[componentId].deferredMajor = getCompProp.resp
+						.Response.deferredFwVersionResp.deferredFwVersion[0];
+					gVersionInfo[componentId].deferredMinor = getCompProp.resp
+						.Response.deferredFwVersionResp.deferredFwVersion[1];
+					gVersionInfo[componentId].deferredAux[0] = getCompProp.resp.Response.deferredFwVersionResp.deferredFwVersion[2];
+					gVersionInfo[componentId].deferredAux[1] = getCompProp.resp.Response.deferredFwVersionResp.deferredFwVersion[3];
+					gVersionInfo[componentId].deferredAux[2] = getCompProp.resp.Response.deferredFwVersionResp.deferredFwVersion[4];
+					gVersionInfo[componentId].deferredAux[3] = getCompProp.resp.Response.deferredFwVersionResp.deferredFwVersion[5];
+				}
+				mode |= ROLLBACK_VER;
+			} else {
+				gVersionInfo[componentId].rollbackMajor = 0xff;
+				gVersionInfo[componentId].rollbackMinor = 0xff;
+				gVersionInfo[componentId].rollbackAux[0] = 0xff;
+				gVersionInfo[componentId].rollbackAux[1] = 0xff;
+				gVersionInfo[componentId].rollbackAux[2] = 0xff;
+				gVersionInfo[componentId].rollbackAux[3] = 0xff;
+				gVersionInfo[componentId].deferredMajor = 0xff;
+				gVersionInfo[componentId].deferredMinor = 0xff;
+				gVersionInfo[componentId].deferredAux[0] = 0xff;
+				gVersionInfo[componentId].deferredAux[1] = 0xff;
+				gVersionInfo[componentId].deferredAux[2] = 0xff;
+				gVersionInfo[componentId].deferredAux[3] = 0xff;
+			}
+			if (gVersionInfo[componentId].coldResetRequired) {
+				/*
+				 * If any of the component indicates that the Payload Cold reset is required
+				 * then set the flag
+				 */
+				flagColdReset = TRUE;
+			}
+			if (option & VIEW_MODE) {
+				HpmDisplayVersion(mode,
+						&gVersionInfo[componentId],
+						0);
+				printf("\n");
+			}
+		}
+	}
+	if (option & VIEW_MODE) {
+		HpmDisplayLine("-",74 );
+		fflush(stdout);
+		lprintf(LOG_NOTICE,
+				"(*) Component requires Payload Cold Reset");
+		printf("\n\n");
+	}
+	return HPMFWUPG_SUCCESS;
+}
+
+/* HpmfwupgUpgrade - perform the HPM.1 firmware upgrade procedure as defined
+ * the IPM Controller Firmware Upgrade Specification version 1.0
+ */
+int
+HpmfwupgUpgrade(struct ipmi_intf *intf, char *imageFilename, int activate,
+		int componentMask, int option)
+{
+	int rc = HPMFWUPG_SUCCESS;
+	struct HpmfwupgUpgradeCtx  fwupgCtx;
+	/* INITIALIZE UPGRADE CONTEXT */
+	memset(&fwupgCtx, 0, sizeof (fwupgCtx));
+	/* GET IMAGE BUFFER FROM FILE */
+	rc = HpmfwupgGetBufferFromFile(imageFilename, &fwupgCtx);
+	/* VALIDATE IMAGE INTEGRITY */
+	if (rc == HPMFWUPG_SUCCESS) {
+		printf("Validating firmware image integrity...");
+		fflush(stdout);
+		rc = HpmfwupgValidateImageIntegrity(&fwupgCtx);
+		if (rc == HPMFWUPG_SUCCESS) {
+			printf("OK\n");
+			fflush(stdout);
+		}
+	}
+	/* PREPARATION STAGE */
+	if (rc == HPMFWUPG_SUCCESS) {
+		printf("Performing preparation stage...");
+		fflush(stdout);
+		rc = HpmfwupgPreparationStage(intf, &fwupgCtx, option);
+		if (rc == HPMFWUPG_SUCCESS) {
+			printf("OK\n");
+			fflush(stdout);
+		}
+	}
+	/* UPGRADE STAGE */
+	if (rc == HPMFWUPG_SUCCESS) {
+		if (option & VIEW_MODE) {
+			lprintf(LOG_NOTICE,
+					"\nComparing Target & Image File version");
+		} else if (option & COMPARE_MODE) {
+			lprintf(LOG_NOTICE,
+					"\nPerforming upload for compare stage:");
+		} else {
+			lprintf(LOG_NOTICE, "\nPerforming upgrade stage:");
+		}
+		if (option & VIEW_MODE) {
+			rc = HpmfwupgPreUpgradeCheck(intf,
+					&fwupgCtx,componentMask, VIEW_MODE);
+		} else {
+			rc = HpmfwupgPreUpgradeCheck(intf, &fwupgCtx,
+					componentMask, option);
+			if (rc == HPMFWUPG_SUCCESS) {
+				if (verbose) {
+					printf("Component update mask : 0x%02x\n",
+							fwupgCtx.compUpdateMask.ComponentBits.byte);
+				}
+				rc = HpmfwupgUpgradeStage(intf, &fwupgCtx, option);
+			}
+		}
+	}
+	/* ACTIVATION STAGE */
+	if (rc == HPMFWUPG_SUCCESS && activate) {
+		/* check if upgrade components mask is non-zero */
+		if (fwupgCtx.compUpdateMask.ComponentBits.byte) {
+			lprintf(LOG_NOTICE, "Performing activation stage: ");
+			rc = HpmfwupgActivationStage(intf, &fwupgCtx);
+		} else {
+			lprintf(LOG_NOTICE,
+					"No components updated. Skipping activation stage.\n");
+		}
+	}
+	if (rc == HPMFWUPG_SUCCESS) {
+		if (option & VIEW_MODE) {
+		/* Dont display anything here in case we are just viewing it */
+		lprintf(LOG_NOTICE," ");
+		} else if (option & COMPARE_MODE) {
+			lprintf(LOG_NOTICE,
+					"\nFirmware comparison procedure complete\n");
+		} else {
+			lprintf(LOG_NOTICE,
+					"\nFirmware upgrade procedure successful\n");
+		}
+	} else if (option & VIEW_MODE) {
+		/* Dont display anything here in case we are just viewing it */
+		lprintf(LOG_NOTICE," ");
+	} else if (option & COMPARE_MODE) {
+		lprintf(LOG_NOTICE,
+				"Firmware comparison procedure failed\n");
+	} else {
+		lprintf(LOG_NOTICE, "Firmware upgrade procedure failed\n");
+	}
+	if (fwupgCtx.pImageData) {
+		free(fwupgCtx.pImageData);
+		fwupgCtx.pImageData = NULL;
+	}
+	return rc;
+}
+
+/* HpmfwupgValidateImageIntegrity - validate a HPM.1 firmware image file as
+ * defined in section 4 of the IPM Controller Firmware Upgrade Specification
+ * version 1.0
+ */
+int
+HpmfwupgValidateImageIntegrity(struct HpmfwupgUpgradeCtx *pFwupgCtx)
+{
+	struct HpmfwupgImageHeader *pImageHeader = (struct HpmfwupgImageHeader*)pFwupgCtx->pImageData;
+	md5_state_t ctx;
+	static unsigned char md[HPMFWUPG_MD5_SIGNATURE_LENGTH];
+	unsigned char *pMd5Sig = pFwupgCtx->pImageData
+		+ (pFwupgCtx->imageSize - HPMFWUPG_MD5_SIGNATURE_LENGTH);
+	/* Validate MD5 checksum */
+	memset(md, 0, HPMFWUPG_MD5_SIGNATURE_LENGTH);
+	memset(&ctx, 0, sizeof(md5_state_t));
+	md5_init(&ctx);
+	md5_append(&ctx, pFwupgCtx->pImageData,
+			pFwupgCtx->imageSize - HPMFWUPG_MD5_SIGNATURE_LENGTH);
+	md5_finish(&ctx, md);
+	if (memcmp(md, pMd5Sig, HPMFWUPG_MD5_SIGNATURE_LENGTH) != 0) {
+		lprintf(LOG_NOTICE, "\n    Invalid MD5 signature");
+		return HPMFWUPG_ERROR;
+	}
+	/* Validate Header signature */
+	if(strncmp(pImageHeader->signature,
+				HPMFWUPG_IMAGE_SIGNATURE,
+				HPMFWUPG_HEADER_SIGNATURE_LENGTH) != 0) {
+		lprintf(LOG_NOTICE,"\n    Invalid image signature");
+		return HPMFWUPG_ERROR;
+	}
+	/* Validate Header image format version */
+	if (pImageHeader->formatVersion != HPMFWUPG_IMAGE_HEADER_VERSION) {
+		lprintf(LOG_NOTICE,"\n    Unrecognized image version");
+		return HPMFWUPG_ERROR;
+	}
+	/* Validate header checksum */
+	if (HpmfwupgCalculateChecksum((unsigned char*)pImageHeader,
+				sizeof(struct HpmfwupgImageHeader)
+				+ pImageHeader->oemDataLength
+				+ sizeof(unsigned char)/*checksum*/) != 0) {
+		lprintf(LOG_NOTICE,"\n    Invalid header checksum");
+		return HPMFWUPG_ERROR;
+	}
+	return HPMFWUPG_SUCCESS;
+}
+
+/* HpmfwupgPreparationStage - prepere stage of a firmware upgrade procedure as
+ * defined in section 3.2 of the IPM Controller Firmware Upgrade Specification
+ * version 1.0
+ */
+int
+HpmfwupgPreparationStage(struct ipmi_intf *intf,
+		struct HpmfwupgUpgradeCtx *pFwupgCtx, int option)
+{
+	int componentId;
+	int rc = HPMFWUPG_SUCCESS;
+	struct HpmfwupgGetTargetUpgCapabilitiesCtx targetCapCmd;
+	struct HpmfwupgImageHeader *pImageHeader = (struct HpmfwupgImageHeader*)
+		pFwupgCtx->pImageData;
+	/* Get device ID */
+	rc = HpmfwupgGetDeviceId(intf, &pFwupgCtx->devId);
+	/* Match current IPMC IDs with upgrade image */
+	if (rc != HPMFWUPG_SUCCESS) {
+		return HPMFWUPG_ERROR;
+	}
+	/* Validate device ID */
+	if (pImageHeader->deviceId == pFwupgCtx->devId.device_id) {
+		/* Validate product ID */
+		if (memcmp(pImageHeader->prodId,
+					pFwupgCtx->devId.product_id,
+					HPMFWUPG_PRODUCT_ID_LENGTH ) == 0) {
+			/* Validate man ID */
+			if (memcmp(pImageHeader->manId,
+						pFwupgCtx->devId.manufacturer_id,
+						HPMFWUPG_MANUFATURER_ID_LENGTH) != 0) {
+				lprintf(LOG_NOTICE,
+						"\n    Invalid image file for manufacturer %u",
+						buf2short(pFwupgCtx->devId.manufacturer_id));
+				rc = HPMFWUPG_ERROR;
+			}
+		} else {
+			lprintf(LOG_NOTICE,
+					"\n    Invalid image file for product %u",
+					buf2short(pFwupgCtx->devId.product_id));
+			rc = HPMFWUPG_ERROR;
+		}
+	} else {
+		lprintf(LOG_NOTICE, "\n    Invalid device ID %x",
+				pFwupgCtx->devId.device_id);
+		rc = HPMFWUPG_ERROR;
+	}
+	if (rc != HPMFWUPG_SUCCESS) {
+		/* Giving one more chance to user to check whether its OK to continue even if the
+		 * product ID does not match. This is helpful as sometimes we just want to update
+		 * and dont care whether we have a different product Id. If the user says NO then
+		 * we need to just bail out from here
+		 */
+		if (!((option & FORCE_MODE) || (option & VIEW_MODE))) {
+			printf("\n\n Use \"force\" option for copying all the components\n");
+			return HPMFWUPG_ERROR;
+		}
+		printf("\n    Image Information");
+		printf("\n        Device Id : 0x%x", pImageHeader->deviceId);
+		printf("\n        Prod   Id : 0x%02x%02x",
+				pImageHeader->prodId[1], pImageHeader->prodId[0]);
+		printf("\n        Manuf  Id : 0x%02x%02x%02x",
+				pImageHeader->manId[2],
+				pImageHeader->manId[1],
+				pImageHeader->manId[0]);
+		printf("\n    Board Information");
+		printf("\n        Device Id : 0x%x", pFwupgCtx->devId.device_id);
+		printf("\n        Prod   Id : 0x%02x%02x",
+				pFwupgCtx->devId.product_id[1], pFwupgCtx->devId.product_id[0]);
+		printf("\n        Manuf  Id : 0x%02x%02x%02x",
+				pFwupgCtx->devId.manufacturer_id[2],
+				pFwupgCtx->devId.manufacturer_id[1],
+				pFwupgCtx->devId.manufacturer_id[0]);
+		if (HpmGetUserInput("\n Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N): ")) {
+			rc = HPMFWUPG_SUCCESS;
+		} else {
+			return HPMFWUPG_ERROR;
+		}
+	}
+	/* Validate earliest compatible revision */
+	/* Validate major & minor revision */
+	if (pImageHeader->compRevision[0] > pFwupgCtx->devId.fw_rev1
+			|| (pImageHeader->compRevision[0] == pFwupgCtx->devId.fw_rev1
+				&& pImageHeader->compRevision[1] > pFwupgCtx->devId.fw_rev2)) {
+		/* Version not compatible for upgrade */
+		lprintf(LOG_NOTICE, "\n    Version: Major: %d", pImageHeader->compRevision[0]);
+		lprintf(LOG_NOTICE, "             Minor: %x", pImageHeader->compRevision[1]);
+		lprintf(LOG_NOTICE, "    Not compatible with ");
+		lprintf(LOG_NOTICE, "    Version: Major: %d", pFwupgCtx->devId.fw_rev1);
+		lprintf(LOG_NOTICE, "             Minor: %x", pFwupgCtx->devId.fw_rev2);
+		/* Confirming it once again */
+		if (!((option & FORCE_MODE) || (option & VIEW_MODE))) {
+			return HPMFWUPG_ERROR;
+		}
+		if (HpmGetUserInput("\n Continue IGNORING Earliest compatibility (Y/N): ")) {
+			rc = HPMFWUPG_SUCCESS;
+		} else {
+			return HPMFWUPG_ERROR;
+		}
+	}
+	/* Get target upgrade capabilities */
+	rc = HpmfwupgGetTargetUpgCapabilities(intf, &targetCapCmd);
+	if (rc != HPMFWUPG_SUCCESS) {
+		return HPMFWUPG_ERROR;
+	}
+	/* Copy response to context */
+	memcpy(&pFwupgCtx->targetCap,
+			&targetCapCmd.resp,
+			sizeof(struct HpmfwupgGetTargetUpgCapabilitiesResp));
+	if (option & VIEW_MODE) {
+		/* do nothing */
+	} else {
+		/* Make sure all component IDs defined in the
+		 * upgrade image are supported by the IPMC
+		 */
+		if ((pImageHeader->components.ComponentBits.byte &
+					pFwupgCtx->targetCap.componentsPresent.ComponentBits.byte) !=
+					pImageHeader->components.ComponentBits.byte) {
+			lprintf(LOG_NOTICE,
+					"\n    Some components present in the image file are not supported by the IPMC");
+			return HPMFWUPG_ERROR;
+		}
+		/* Make sure the upgrade is desirable rigth now */
+		if (pFwupgCtx->targetCap.GlobalCapabilities.bitField.fwUpgUndesirable == 1) {
+			lprintf(LOG_NOTICE, "\n    Upgrade undesirable at this moment");
+			return HPMFWUPG_ERROR;
+		}
+		/* Get confimation from the user if he wants to continue when
+		 * service affected during upgrade
+		 */
+		if (!(option & COMPARE_MODE)
+				&& (pFwupgCtx->targetCap.GlobalCapabilities.bitField.servAffectDuringUpg == 1
+					|| pImageHeader->imageCapabilities.bitField.servAffected == 1)) {
+			if (HpmGetUserInput("\nServices may be affected during upgrade. Do you wish to continue? (y/n): ")) {
+				rc = HPMFWUPG_SUCCESS;
+			} else {
+				return HPMFWUPG_ERROR;
+			}
+		}
+	}
+	/* Get the general properties of each component present in image */
+	for (componentId = HPMFWUPG_COMPONENT_ID_0;
+			componentId < HPMFWUPG_COMPONENT_ID_MAX;
+			componentId++) {
+		/* Reset component properties */
+		memset(&pFwupgCtx->genCompProp[componentId], 0,
+				sizeof (struct HpmfwupgGetGeneralPropResp));
+		if ((1 << componentId & pImageHeader->components.ComponentBits.byte)) {
+			struct HpmfwupgGetComponentPropertiesCtx getCompPropCmd;
+			/* Get general component properties */
+			getCompPropCmd.req.componentId = componentId;
+			getCompPropCmd.req.selector = HPMFWUPG_COMP_GEN_PROPERTIES;
+			rc = HpmfwupgGetComponentProperties(intf, &getCompPropCmd);
+			if (rc == HPMFWUPG_SUCCESS) {
+				/* Copy response to context */
+				memcpy(&pFwupgCtx->genCompProp[componentId],
+						&getCompPropCmd.resp,
+						sizeof(struct HpmfwupgGetGeneralPropResp));
+			}
+		}
+	}
+	return rc;
+}
+
+int
+image_version_upgradable(VERSIONINFO *pVersionInfo)
+{
+	/* If the image and active target versions are different, then
+	 * upgrade */
+	if ((pVersionInfo->imageMajor != pVersionInfo->targetMajor)
+			|| (pVersionInfo->imageMinor != pVersionInfo->targetMinor)
+			|| (pVersionInfo->imageAux[0] != pVersionInfo->targetAux[0])
+			|| (pVersionInfo->imageAux[1] != pVersionInfo->targetAux[1])
+			|| (pVersionInfo->imageAux[2] != pVersionInfo->targetAux[2])
+			|| (pVersionInfo->imageAux[3] != pVersionInfo->targetAux[3])) {
+		return (1);
+	}
+	/* If the image and active target versions are the same and rollback
+	 * is not supported, then there's nothing to do, skip the upgrade
+	 */
+	if (!pVersionInfo->rollbackSupported) {
+		return (0);
+	}
+	/* If the image and rollback target versions are different, then
+	 * go ahead and upgrade
+	 */
+	if ((pVersionInfo->imageMajor != pVersionInfo->rollbackMajor)
+			|| (pVersionInfo->imageMinor != pVersionInfo->rollbackMinor)
+			|| (pVersionInfo->imageAux[0] != pVersionInfo->rollbackAux[0])
+			|| (pVersionInfo->imageAux[1] != pVersionInfo->rollbackAux[1])
+			|| (pVersionInfo->imageAux[2] != pVersionInfo->rollbackAux[2])
+			|| (pVersionInfo->imageAux[3] != pVersionInfo->rollbackAux[3])) {
+		return (1);
+	}
+	/* Image and rollback target versions are the same too, skip it */
+	return (0);
+}
+
+/* HpmfwupgValidateActionRecordChecksum - validate checksum of the specified
+ * action record header.
+ */
+int
+HpmfwupgValidateActionRecordChecksum(struct HpmfwupgActionRecord *pActionRecord)
+{
+	int rc = HPMFWUPG_SUCCESS;
+	/* Validate action record checksum */
+	if (HpmfwupgCalculateChecksum((unsigned char*)pActionRecord,
+				sizeof(struct HpmfwupgActionRecord)) != 0) {
+	/* Due to ambiguity in the HPM.1 specification, for the case of
+	 * the Upload Firmware Image action type, the record header length
+	 * might be thought as either the first 3 bytes, or the first 34 bytes
+	 * which precede the firmware image data.
+	 * For the latter case we re-calculate the Upload Firmware Image
+	 * record checksum for the 34 byte header length.
+	 */
+		if (pActionRecord->actionType != HPMFWUPG_ACTION_UPLOAD_FIRMWARE
+				|| HpmfwupgCalculateChecksum((unsigned char*)pActionRecord,
+					sizeof(struct HpmfwupgActionRecord)
+					+ sizeof(struct HpmfwupgFirmwareImage))) {
+			lprintf(LOG_NOTICE, "    Invalid Action record.");
+			rc = HPMFWUPG_ERROR;
+		}
+	}
+	return rc;
+}
+
+/* HpmfwupgPreUpgradeCheck - make pre-Upgrade check, this mainly helps in
+ * checking which all version upgrade is skippable because the image version
+ * is same as target version.
+ */
+int
+HpmfwupgPreUpgradeCheck(struct ipmi_intf *intf,
+		struct HpmfwupgUpgradeCtx *pFwupgCtx,
+		int componentMask, int option)
+{
+	unsigned char *pImagePtr;
+	struct HpmfwupgActionRecord *pActionRecord;
+	struct HpmfwupgImageHeader *pImageHeader;
+	int componentId;
+	pImageHeader = (struct HpmfwupgImageHeader*)pFwupgCtx->pImageData;
+	/* Put pointer after image header */
+	pImagePtr = (unsigned char*)(pFwupgCtx->pImageData
+			+ sizeof(struct HpmfwupgImageHeader)
+			+ pImageHeader->oemDataLength
+			+ sizeof(unsigned char)/*chksum*/);
+	if (option & VIEW_MODE) {
+		HpmDisplayVersionHeader(TARGET_VER|ROLLBACK_VER|IMAGE_VER);
+	}
+	/* Perform actions defined in the image */
+	while (pImagePtr < (pFwupgCtx->pImageData + pFwupgCtx->imageSize
+				- HPMFWUPG_MD5_SIGNATURE_LENGTH)) {
+		/* Get action record */
+		pActionRecord = (struct HpmfwupgActionRecord*)pImagePtr;
+		/* Validate action record checksum */
+		if (HpmfwupgValidateActionRecordChecksum(pActionRecord) != HPMFWUPG_SUCCESS) {
+			return HPMFWUPG_ERROR;
+		}
+		/* Validate affected components */
+		if (pActionRecord->components.ComponentBits.byte
+				&& !pFwupgCtx->targetCap.componentsPresent.ComponentBits.byte) {
+			lprintf(LOG_NOTICE,
+					"    Invalid action record. One or more affected components is not supported");
+			return HPMFWUPG_ERROR;
+		}
+		switch (pActionRecord->actionType) {
+		case HPMFWUPG_ACTION_BACKUP_COMPONENTS:
+			{
+				/* Make sure every component specified by
+				 * this action record
+				 * supports the backup operation
+				 */
+				for (componentId = HPMFWUPG_COMPONENT_ID_0;
+						componentId < HPMFWUPG_COMPONENT_ID_MAX;
+						componentId++) {
+					if (((1 << componentId) & pActionRecord->components.ComponentBits.byte)
+							&& pFwupgCtx->genCompProp[componentId].GeneralCompProperties.bitfield.rollbackBackup == 0) {
+						lprintf(LOG_NOTICE,
+								"    Component ID %d does not support backup",
+								componentId);
+						return HPMFWUPG_ERROR;
+					}
+				}
+				pImagePtr += sizeof(struct HpmfwupgActionRecord);
+			}
+			break;
+		case HPMFWUPG_ACTION_PREPARE_COMPONENTS:
+			{
+				/* Make sure every components specified by
+				 * this action
+				 * supports the prepare operation
+				 */
+				for (componentId = HPMFWUPG_COMPONENT_ID_0;
+						componentId < HPMFWUPG_COMPONENT_ID_MAX;
+						componentId++) {
+					if (((1 << componentId) & pActionRecord->components.ComponentBits.byte)
+							&& pFwupgCtx->genCompProp[componentId].GeneralCompProperties.bitfield.preparationSupport == 0) {
+						lprintf(LOG_NOTICE,
+								"    Component ID %d does not support preparation",
+								componentId);
+						return HPMFWUPG_ERROR;
+					}
+				}
+				pImagePtr += sizeof(struct HpmfwupgActionRecord);
+			}
+			break;
+		case HPMFWUPG_ACTION_UPLOAD_FIRMWARE:
+			/* Upload all firmware blocks */
+			{
+				struct HpmfwupgFirmwareImage *pFwImage;
+				unsigned char *pData;
+				unsigned int firmwareLength;
+				unsigned char mode;
+				unsigned char componentId;
+				unsigned char componentIdByte;
+				unsigned int upgrade_comp;
+				VERSIONINFO *pVersionInfo;
+				/* Save component ID on which the upload is done */
+				componentIdByte = pActionRecord->components.ComponentBits.byte;
+				componentId = 0;
+				while ((componentIdByte >>= 1) != 0) {
+					componentId++;
+				}
+				pFwImage = (struct HpmfwupgFirmwareImage*)(pImagePtr
+						+ sizeof(struct HpmfwupgActionRecord));
+				pData = ((unsigned char*)pFwImage
+						+ sizeof(struct HpmfwupgFirmwareImage));
+				/* Get firmware length */
+				firmwareLength  =  pFwImage->length[0];
+				firmwareLength |= (pFwImage->length[1] << 8)  & 0xff00;
+				firmwareLength |= (pFwImage->length[2] << 16) & 0xff0000;
+				firmwareLength |= (pFwImage->length[3] << 24) & 0xff000000;
+
+				pVersionInfo = &gVersionInfo[componentId];
+
+				pVersionInfo->imageMajor   = pFwImage->version[0];
+				pVersionInfo->imageMinor   = pFwImage->version[1];
+				pVersionInfo->imageAux[0]  = pFwImage->version[2];
+				pVersionInfo->imageAux[1]  = pFwImage->version[3];
+				pVersionInfo->imageAux[2]  = pFwImage->version[4];
+				pVersionInfo->imageAux[3]  = pFwImage->version[5];
+
+				mode = TARGET_VER | IMAGE_VER;
+				/* check if component is selected for upgrade */
+				upgrade_comp = !componentMask
+					|| (componentMask & pActionRecord->components.ComponentBits.byte);
+				/* check if current component version requires upgrade */
+				if (upgrade_comp && !(option & (FORCE_MODE|COMPARE_MODE))) {
+					upgrade_comp = image_version_upgradable(pVersionInfo);
+				}
+				if (verbose) {
+					lprintf(LOG_NOTICE,
+							"%s component %d",
+							(upgrade_comp ? "Updating" : "Skipping"), 
+							componentId);
+				}
+				if (upgrade_comp) {
+					pFwupgCtx->compUpdateMask.ComponentBits.byte|= 1 << componentId;
+				}
+				if (option & VIEW_MODE) {
+					if (pVersionInfo->rollbackSupported) {
+						mode|= ROLLBACK_VER;
+					}
+					HpmDisplayVersion(mode,pVersionInfo, upgrade_comp);
+					printf("\n");
+				}
+				pImagePtr = pData + firmwareLength;
+			}
+			break;
+		default:
+			lprintf(LOG_NOTICE,
+					"    Invalid Action type. Cannot continue");
+			return HPMFWUPG_ERROR;
+			break;
+		}
+	}
+	if (option & VIEW_MODE) {
+		HpmDisplayLine("-",74);
+		fflush(stdout);
+		lprintf(LOG_NOTICE,
+				"(*) Component requires Payload Cold Reset");
+		lprintf(LOG_NOTICE,
+				"(^) Indicates component would be upgraded");
+	}
+	return HPMFWUPG_SUCCESS;
+}
+
+/* HpmfwupgUpgradeStage - upgrade stage of a firmware upgrade procedure as
+ * defined in section 3.3 of the IPM Controller Firmware Upgrade Specification
+ * version 1.0
+ */
+int
+HpmfwupgUpgradeStage(struct ipmi_intf *intf,
+		struct HpmfwupgUpgradeCtx *pFwupgCtx, int option)
+{
+	struct HpmfwupgImageHeader *pImageHeader = (struct HpmfwupgImageHeader*)
+		pFwupgCtx->pImageData;
+	struct HpmfwupgActionRecord* pActionRecord;
+	int rc = HPMFWUPG_SUCCESS;
+	unsigned char *pImagePtr;
+	unsigned int actionsSize;
+	int flagColdReset = FALSE;
+	time_t start,end;
+	/* Put pointer after image header */
+	pImagePtr = (unsigned char*)
+		(pFwupgCtx->pImageData + sizeof(struct HpmfwupgImageHeader) +
+		pImageHeader->oemDataLength + sizeof(unsigned char)/*checksum*/);
+	/* Deternime actions size */
+	actionsSize = pFwupgCtx->imageSize - sizeof(struct HpmfwupgImageHeader);
+	if (!(option & VIEW_MODE)) {
+		HpmDisplayUpgradeHeader();
+	}
+	/* Perform actions defined in the image */
+	while (( pImagePtr < (pFwupgCtx->pImageData + pFwupgCtx->imageSize -
+					HPMFWUPG_MD5_SIGNATURE_LENGTH))
+			&& (rc == HPMFWUPG_SUCCESS)) {
+		/* Get action record */
+		pActionRecord = (struct HpmfwupgActionRecord*)pImagePtr;
+		/* Validate action record checksum */
+		rc = HpmfwupgValidateActionRecordChecksum(pActionRecord);
+		if (rc != HPMFWUPG_SUCCESS) {
+			continue;
+		}
+		switch(pActionRecord->actionType) {
+		case HPMFWUPG_ACTION_BACKUP_COMPONENTS:
+			{
+				if (!(option & COMPARE_MODE)) {
+					/* Send Upgrade Action command */
+					struct HpmfwupgInitiateUpgradeActionCtx initUpgActionCmd;
+					/* Affect only selected components */
+					initUpgActionCmd.req.componentsMask.ComponentBits.byte =
+						pFwupgCtx->compUpdateMask.ComponentBits.byte &
+						pActionRecord->components.ComponentBits.byte;
+					/* Action is prepare components */
+					if (initUpgActionCmd.req.componentsMask.ComponentBits.byte) {
+						initUpgActionCmd.req.upgradeAction  = HPMFWUPG_UPGRADE_ACTION_BACKUP;
+						rc = HpmfwupgInitiateUpgradeAction(intf, &initUpgActionCmd, pFwupgCtx);
+					}
+				}
+				pImagePtr+= sizeof(struct HpmfwupgActionRecord);
+			}
+			break;
+		case HPMFWUPG_ACTION_PREPARE_COMPONENTS:
+			{
+				if (!(option & COMPARE_MODE)) {
+					/* Send prepare components command */
+					struct HpmfwupgInitiateUpgradeActionCtx initUpgActionCmd;
+					/* Affect only selected components */
+					initUpgActionCmd.req.componentsMask.ComponentBits.byte =
+						pFwupgCtx->compUpdateMask.ComponentBits.byte &
+						pActionRecord->components.ComponentBits.byte;
+					if (initUpgActionCmd.req.componentsMask.ComponentBits.byte) {
+						/* Action is prepare components */
+						initUpgActionCmd.req.upgradeAction = HPMFWUPG_UPGRADE_ACTION_PREPARE;
+						rc = HpmfwupgInitiateUpgradeAction(intf, &initUpgActionCmd, pFwupgCtx);
+					}
+				}
+				pImagePtr+= sizeof(struct HpmfwupgActionRecord);
+			}
+			break;
+		case HPMFWUPG_ACTION_UPLOAD_FIRMWARE:
+			/* Upload all firmware blocks */
+			rc = HpmFwupgActionUploadFirmware(pActionRecord->components,
+					pFwupgCtx,
+					&pImagePtr,
+					intf,
+					option,
+					&flagColdReset);
+			break;
+		default:
+			lprintf(LOG_NOTICE, "    Invalid Action type. Cannot continue");
+			rc = HPMFWUPG_ERROR;
+			break;
+		}
+	}
+	HpmDisplayLine("-", 79);
+	fflush(stdout);
+	lprintf(LOG_NOTICE, "(*) Component requires Payload Cold Reset");
+	return rc;
+}
+
+int
+HpmFwupgActionUploadFirmware(struct HpmfwupgComponentBitMask components,
+		struct HpmfwupgUpgradeCtx *pFwupgCtx,
+		unsigned char **pImagePtr,
+		struct ipmi_intf *intf,
+		int option,
+		int *pFlagColdReset)
+{
+	struct HpmfwupgFirmwareImage *pFwImage;
+	struct HpmfwupgInitiateUpgradeActionCtx initUpgActionCmd;
+	struct HpmfwupgUploadFirmwareBlockCtx uploadCmd;
+	struct HpmfwupgFinishFirmwareUploadCtx finishCmd;
+	VERSIONINFO *pVersionInfo;
+	time_t start,end;
+
+	int rc = HPMFWUPG_SUCCESS;
+	int skip = TRUE;
+	unsigned char *pData, *pDataInitial;
+	unsigned short count;
+	unsigned int totalSent = 0;
+	unsigned short bufLength = 0;
+	unsigned short bufLengthIsSet = 0;
+	unsigned int firmwareLength = 0;
+
+	unsigned int displayFWLength = 0;
+	unsigned char *pDataTemp;
+	unsigned int imageOffset = 0x00;
+	unsigned int blockLength = 0x00;
+	unsigned int lengthOfBlock = 0x00;
+	unsigned int numTxPkts = 0;
+	unsigned int numRxPkts = 0;
+	unsigned char mode = 0;
+	unsigned char componentId = 0x00;
+	unsigned char componentIdByte = 0x00;
+	uint16_t max_rq_size;
+
+	/* Save component ID on which the upload is done */
+	componentIdByte = components.ComponentBits.byte;
+	while ((componentIdByte>>= 1) != 0) {
+		componentId++;
+	}
+	pFwupgCtx->componentId = componentId;
+	pVersionInfo = (VERSIONINFO *)&gVersionInfo[componentId];
+	pFwImage = (struct HpmfwupgFirmwareImage*)((*pImagePtr)
+			+ sizeof(struct HpmfwupgActionRecord));
+	pDataInitial = ((unsigned char *)pFwImage
+			+ sizeof(struct HpmfwupgFirmwareImage));
+	pData = pDataInitial;
+
+	/* Find max buffer length according the connection parameters */
+	max_rq_size = ipmi_intf_get_max_request_data_size(intf);
+
+	/* validate lower bound of max request size */
+	if (max_rq_size <= sizeof(struct HpmfwupgUploadFirmwareBlockReq)) {
+		lprintf(LOG_ERROR, "Maximum request size is too small to "
+				"send a upload request.");
+		return HPMFWUPG_ERROR;
+	}
+
+	bufLength = max_rq_size - sizeof(struct HpmfwupgUploadFirmwareBlockReq);
+
+	/* Get firmware length */
+	firmwareLength =  pFwImage->length[0];
+	firmwareLength|= (pFwImage->length[1] << 8)  & 0xff00;
+	firmwareLength|= (pFwImage->length[2] << 16) & 0xff0000;
+	firmwareLength|= (pFwImage->length[3] << 24) & 0xff000000;
+	mode = TARGET_VER | IMAGE_VER;
+	if (pVersionInfo->rollbackSupported) {
+		mode |= ROLLBACK_VER;
+	}
+	if ((option & DEBUG_MODE)) {
+		printf("\n\n Comp ID : %d	 [%-20s]\n",
+				pVersionInfo->componentId,
+				pFwImage->desc);
+	} else {
+		HpmDisplayVersion(mode, pVersionInfo, 0);
+	}
+	if ((1 << componentId) & pFwupgCtx->compUpdateMask.ComponentBits.byte) {
+		if (verbose) {
+			lprintf(LOG_NOTICE, "Do not skip %d",
+					componentId);
+		}
+		skip = FALSE;
+	}
+	if (!skip) {
+		HpmDisplayUpgrade(0,0,1,0);
+		/* Initialize parameters */
+		uploadCmd.req = malloc(max_rq_size);
+		if (!uploadCmd.req) {
+			lprintf(LOG_ERR, "ipmitool: malloc failure");
+			return HPMFWUPG_ERROR;
+		}
+		uploadCmd.req->blockNumber = 0;
+		/* Send Initiate Upgrade Action */
+		initUpgActionCmd.req.componentsMask = components;
+		if (option & COMPARE_MODE) {
+			/* Action is compare */
+			initUpgActionCmd.req.upgradeAction = HPMFWUPG_UPGRADE_ACTION_COMPARE;
+		} else {
+			/* Action is upgrade */
+			initUpgActionCmd.req.upgradeAction = HPMFWUPG_UPGRADE_ACTION_UPGRADE;
+		}
+		rc = HpmfwupgInitiateUpgradeAction(intf, &initUpgActionCmd, pFwupgCtx);
+		if (rc != HPMFWUPG_SUCCESS) {
+			skip = TRUE;
+		}
+		if ((pVersionInfo->coldResetRequired) && (!skip)) {
+			*pFlagColdReset = TRUE;
+		}
+		/* pDataInitial is the starting pointer of the image data  */
+		/* pDataTemp is one which we will move across */
+		pData = pDataInitial;
+		pDataTemp = pDataInitial;
+		lengthOfBlock = firmwareLength;
+		totalSent = 0x00;
+		displayFWLength= firmwareLength;
+		time(&start);
+		while ((pData < (pDataTemp+lengthOfBlock)) && (rc == HPMFWUPG_SUCCESS)) {
+			if ((pData+bufLength) <= (pDataTemp+lengthOfBlock)) {
+				count = bufLength;
+			} else {
+				count = (unsigned short)((pDataTemp+lengthOfBlock) - pData);
+			}
+			memcpy(&uploadCmd.req->data, pData, bufLength);
+			imageOffset = 0x00;
+			blockLength = 0x00;
+			numTxPkts++;
+			rc = HpmfwupgUploadFirmwareBlock(intf, &uploadCmd,
+					pFwupgCtx, count, &imageOffset,&blockLength);
+			numRxPkts++;
+			if (rc != HPMFWUPG_SUCCESS) {
+				if (rc == HPMFWUPG_UPLOAD_BLOCK_LENGTH && !bufLengthIsSet) {
+					rc = HPMFWUPG_SUCCESS;
+					/* Retry with a smaller buffer length */
+					if (strstr(intf->name,"lan") != NULL && bufLength > 8) {
+						bufLength-= 8;
+						lprintf(LOG_INFO,
+								"Trying reduced buffer length: %d",
+								bufLength);
+					} else if (bufLength) {
+						bufLength-= 1;
+						lprintf(LOG_INFO,
+								"Trying reduced buffer length: %d",
+								bufLength);
+					} else {
+						rc = HPMFWUPG_ERROR;
+					}
+				} else if (rc == HPMFWUPG_UPLOAD_RETRY) {
+					rc = HPMFWUPG_SUCCESS;
+				} else {
+					fflush(stdout);
+					lprintf(LOG_NOTICE,
+							"\n Error in Upload FIRMWARE command [rc=%d]\n",
+							rc);
+					lprintf(LOG_NOTICE,
+							"\n TotalSent:0x%x ",
+							totalSent);
+					/* Exiting from the function */
+					rc = HPMFWUPG_ERROR;
+				}
+			} else {
+				/* success, buf length is valid */
+				bufLengthIsSet = 1;
+				if (blockLength > firmwareLength) {
+					/*
+					 * blockLength is the remaining length of the firmware to upload so
+					 * if its greater than the firmware length then its kind of error
+					 */
+					lprintf(LOG_NOTICE,
+							"\n Error in Upload FIRMWARE command [rc=%d]\n",
+							rc);
+					lprintf(LOG_NOTICE,
+							"\n TotalSent:0x%x Img offset:0x%x  Blk length:0x%x  Fwlen:0x%x\n",
+							totalSent,imageOffset,blockLength,firmwareLength);
+					rc = HPMFWUPG_ERROR;
+				}
+				totalSent += count;
+				if (imageOffset != 0x00) {
+					/* block Length is valid  */
+					lengthOfBlock = blockLength;
+					pDataTemp = pDataInitial + imageOffset;
+					pData = pDataTemp;
+					if (displayFWLength == firmwareLength) {
+						/* This is basically used only to make sure that we display uptil 100% */
+						displayFWLength = blockLength + totalSent;
+					}
+				} else {
+					pData += count;
+				}
+				time(&end);
+				/*
+				 * Just added debug mode in case we need to see exactly how many bytes have
+				 * gone through - Its a hidden option used mainly should be used for debugging
+				 */
+				if (option & DEBUG_MODE) {
+					fflush(stdout);
+					printf(" Blk Num : %02x        Bytes : %05x ",
+							uploadCmd.req->blockNumber,totalSent);
+					if (imageOffset || blockLength) {
+						printf("\n--> ImgOff : %x BlkLen : %x\n",
+								imageOffset,blockLength);
+					}
+					if (displayFWLength == totalSent) {
+						printf("\n Time Taken %02ld:%02ld",
+								(end-start)/60, (end-start)%60);
+						printf("\n\n");
+					}
+				} else {
+					HpmDisplayUpgrade(0, totalSent,
+							displayFWLength, (end-start));
+				}
+				uploadCmd.req->blockNumber++;
+			}
+		}
+		/* free buffer */
+		free(uploadCmd.req);
+		uploadCmd.req = NULL;
+	}
+	if (skip) {
+		HpmDisplayUpgrade(1,0,0,0);
+		if ((option & COMPARE_MODE)
+				&& !pFwupgCtx->genCompProp[pFwupgCtx->componentId].GeneralCompProperties.bitfield.comparisonSupport) {
+			printf("|    |Comparison isn't supported for given compenent.                        |\n");
+		}
+		*pImagePtr = pDataInitial + firmwareLength;
+	}
+	if (rc == HPMFWUPG_SUCCESS && !skip) {
+		/* Send finish component */
+		/* Set image length */
+		finishCmd.req.componentId = componentId;
+		/* We need to send the actual data that is sent
+		 * not the comlete firmware image length
+		 */
+		finishCmd.req.imageLength[0] = totalSent & 0xFF;
+		finishCmd.req.imageLength[1] = (totalSent >> 8) & 0xFF;
+		finishCmd.req.imageLength[2] = (totalSent >> 16) & 0xFF;
+		finishCmd.req.imageLength[3] = (totalSent >> 24) & 0xFF;
+		rc = HpmfwupgFinishFirmwareUpload(intf, &finishCmd,
+				pFwupgCtx, option);
+		*pImagePtr = pDataInitial + firmwareLength;
+	}
+	return rc;
+}
+
+/* HpmfwupgActivationStage - validate stage of a firmware upgrade procedure as
+ * defined in section 3.4 of the IPM Controller Firmware Upgrade Specification
+ * version 1.0
+ */
+int
+HpmfwupgActivationStage(struct ipmi_intf *intf,
+		struct HpmfwupgUpgradeCtx *pFwupgCtx)
+{
+	int rc = HPMFWUPG_SUCCESS;
+	struct HpmfwupgActivateFirmwareCtx activateCmd;
+	struct HpmfwupgImageHeader *pImageHeader = (struct HpmfwupgImageHeader*)
+		pFwupgCtx->pImageData;
+	/* Print out stuf...*/
+	printf("    ");
+	fflush(stdout);
+	/* Activate new firmware */
+	activateCmd.req.rollback_override = 0;
+	rc = HpmfwupgActivateFirmware(intf, &activateCmd, pFwupgCtx);
+	if (rc == HPMFWUPG_SUCCESS) {
+		/* Query self test result if supported by target and new image */
+		if ((pFwupgCtx->targetCap.GlobalCapabilities.bitField.ipmcSelftestCap == 1)
+				|| (pImageHeader->imageCapabilities.bitField.imageSelfTest == 1)) {
+			struct HpmfwupgQuerySelftestResultCtx selfTestCmd;
+			rc = HpmfwupgQuerySelftestResult(intf, &selfTestCmd,
+					pFwupgCtx);
+			if (rc == HPMFWUPG_SUCCESS) {
+				/* Get the self test result */
+				if (selfTestCmd.resp.result1 != 0x55) {
+					/* Perform manual rollback if necessary */
+					/* BACKUP/ MANUAL ROLLBACK not supported by this UA */
+					lprintf(LOG_NOTICE, "    Self test failed:");
+					lprintf(LOG_NOTICE, "    Result1 = %x",
+							selfTestCmd.resp.result1);
+					lprintf(LOG_NOTICE, "    Result2 = %x",
+							selfTestCmd.resp.result2);
+					rc = HPMFWUPG_ERROR;
+				}
+			} else {
+				/* Perform manual rollback if necessary */
+				/* BACKUP / MANUAL ROLLBACK not supported by this UA */
+				lprintf(LOG_NOTICE,"    Self test failed.");
+			}
+		}
+	}
+	/* If activation / self test failed, query rollback
+	 * status if automatic rollback supported
+	 */
+	if (rc == HPMFWUPG_ERROR) {
+		if ((pFwupgCtx->targetCap.GlobalCapabilities.bitField.autRollback == 1)
+				&& (pFwupgCtx->genCompProp[pFwupgCtx->componentId].GeneralCompProperties.bitfield.rollbackBackup != 0x00)) {
+			struct HpmfwupgQueryRollbackStatusCtx rollCmd;
+			lprintf(LOG_NOTICE,"    Getting rollback status...");
+			fflush(stdout);
+			rc = HpmfwupgQueryRollbackStatus(intf,
+					&rollCmd, pFwupgCtx);
+		}
+	}
+	return rc;
+}
+
+int
+HpmfwupgGetBufferFromFile(char *imageFilename,
+		struct HpmfwupgUpgradeCtx *pFwupgCtx)
+{
+	int rc = HPMFWUPG_SUCCESS;
+	int ret = 0;
+	FILE *pImageFile = fopen(imageFilename, "rb");
+	if (pImageFile == NULL) {
+		lprintf(LOG_ERR, "Cannot open image file '%s'",
+				imageFilename);
+		return HPMFWUPG_ERROR;
+	}
+	/* Get the raw data in file */
+	fseek(pImageFile, 0, SEEK_END);
+	pFwupgCtx->imageSize  = ftell(pImageFile);
+	pFwupgCtx->pImageData = malloc(sizeof(unsigned char)*pFwupgCtx->imageSize);
+	if (pFwupgCtx->pImageData == NULL) {
+		lprintf(LOG_ERR, "ipmitool: malloc failure");
+		fclose(pImageFile);
+		return HPMFWUPG_ERROR;
+	}
+	rewind(pImageFile);
+	ret = fread(pFwupgCtx->pImageData,
+			sizeof(unsigned char),
+			pFwupgCtx->imageSize,
+			pImageFile);
+	if (ret != pFwupgCtx->imageSize) {
+		lprintf(LOG_ERR,
+				"Failed to read file %s size %d", 
+				imageFilename,
+				pFwupgCtx->imageSize);
+		rc = HPMFWUPG_ERROR;
+	}
+	fclose(pImageFile);
+	return rc;
+}
+
+int
+HpmfwupgGetDeviceId(struct ipmi_intf *intf, struct ipm_devid_rsp *pGetDevId)
+{
+	struct ipmi_rs *rsp;
+	struct ipmi_rq req;
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_APP;
+	req.msg.cmd = BMC_GET_DEVICE_ID;
+	req.msg.data_len = 0;
+	rsp = HpmfwupgSendCmd(intf, req, NULL);
+	if (rsp == NULL) {
+		lprintf(LOG_ERR, "Error getting device ID.");
+		return HPMFWUPG_ERROR;
+	}
+	if (rsp->ccode != 0x00) {
+		lprintf(LOG_ERR, "Error getting device ID.");
+		lprintf(LOG_ERR, "compcode=0x%x: %s",
+				rsp->ccode,
+				val2str(rsp->ccode, completion_code_vals));
+		return HPMFWUPG_ERROR;
+	}
+	memcpy(pGetDevId, rsp->data, sizeof(struct ipm_devid_rsp));
+	return HPMFWUPG_SUCCESS;
+}
+
+int
+HpmfwupgGetTargetUpgCapabilities(struct ipmi_intf *intf,
+		struct HpmfwupgGetTargetUpgCapabilitiesCtx *pCtx)
+{
+	struct ipmi_rs *rsp;
+	struct ipmi_rq req;
+	pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_PICMG;
+	req.msg.cmd = HPMFWUPG_GET_TARGET_UPG_CAPABILITIES;
+	req.msg.data = (unsigned char*)&pCtx->req;
+	req.msg.data_len = sizeof(struct HpmfwupgGetTargetUpgCapabilitiesReq);
+	rsp = HpmfwupgSendCmd(intf, req, NULL);
+	if (rsp == NULL) {
+		lprintf(LOG_ERR,
+				"Error getting target upgrade capabilities.");
+		return HPMFWUPG_ERROR;
+	}
+	if (rsp->ccode != 0x00) {
+		lprintf(LOG_ERR,
+				"Error getting target upgrade capabilities, ccode: 0x%x: %s",
+				rsp->ccode,
+				val2str(rsp->ccode, completion_code_vals));
+		return HPMFWUPG_ERROR;
+	}
+	memcpy(&pCtx->resp, rsp->data,
+			sizeof(struct HpmfwupgGetTargetUpgCapabilitiesResp));
+	if (verbose) {
+		lprintf(LOG_NOTICE, "TARGET UPGRADE CAPABILITIES");
+		lprintf(LOG_NOTICE, "-------------------------------");
+		lprintf(LOG_NOTICE, "HPM.1 version............%d    ",
+				pCtx->resp.hpmVersion);
+		lprintf(LOG_NOTICE, "Component 0 presence....[%c]   ",
+				pCtx->resp.componentsPresent.ComponentBits.bitField.component0 ? 'y' : 'n');
+		lprintf(LOG_NOTICE, "Component 1 presence....[%c]   ",
+				pCtx->resp.componentsPresent.ComponentBits.bitField.component1 ? 'y' : 'n');
+		lprintf(LOG_NOTICE, "Component 2 presence....[%c]   ",
+				pCtx->resp.componentsPresent.ComponentBits.bitField.component2 ? 'y' : 'n');
+		lprintf(LOG_NOTICE, "Component 3 presence....[%c]   ",
+				pCtx->resp.componentsPresent.ComponentBits.bitField.component3 ? 'y' : 'n');
+		lprintf(LOG_NOTICE, "Component 4 presence....[%c]   ",
+				pCtx->resp.componentsPresent.ComponentBits.bitField.component4 ? 'y' : 'n');
+		lprintf(LOG_NOTICE, "Component 5 presence....[%c]   ",
+				pCtx->resp.componentsPresent.ComponentBits.bitField.component5 ? 'y' : 'n');
+		lprintf(LOG_NOTICE, "Component 6 presence....[%c]   ",
+				pCtx->resp.componentsPresent.ComponentBits.bitField.component6 ? 'y' : 'n');
+		lprintf(LOG_NOTICE, "Component 7 presence....[%c]   ",
+				pCtx->resp.componentsPresent.ComponentBits.bitField.component7 ? 'y' : 'n');
+		lprintf(LOG_NOTICE, "Upgrade undesirable.....[%c]   ",
+				pCtx->resp.GlobalCapabilities.bitField.fwUpgUndesirable ? 'y' : 'n');
+		lprintf(LOG_NOTICE, "Aut rollback override...[%c]   ",
+				pCtx->resp.GlobalCapabilities.bitField.autRollbackOverride ? 'y' : 'n');
+		lprintf(LOG_NOTICE, "IPMC degraded...........[%c]   ",
+				pCtx->resp.GlobalCapabilities.bitField.ipmcDegradedDurinUpg ? 'y' : 'n');
+		lprintf(LOG_NOTICE, "Defered activation......[%c]   ",
+				pCtx->resp.GlobalCapabilities.bitField.deferActivation ? 'y' : 'n');
+		lprintf(LOG_NOTICE, "Service affected........[%c]   ",
+				pCtx->resp.GlobalCapabilities.bitField.servAffectDuringUpg ? 'y' : 'n');
+		lprintf(LOG_NOTICE, "Manual rollback.........[%c]   ",
+				pCtx->resp.GlobalCapabilities.bitField.manualRollback ? 'y' : 'n');
+		lprintf(LOG_NOTICE, "Automatic rollback......[%c]   ",
+				pCtx->resp.GlobalCapabilities.bitField.autRollback ? 'y' : 'n');
+		lprintf(LOG_NOTICE, "Self test...............[%c]   ",
+				pCtx->resp.GlobalCapabilities.bitField.ipmcSelftestCap ? 'y' : 'n');
+		lprintf(LOG_NOTICE, "Upgrade timeout.........[%d sec] ",
+				pCtx->resp.upgradeTimeout*5);
+		lprintf(LOG_NOTICE, "Self test timeout.......[%d sec] ",
+				pCtx->resp.selftestTimeout*5);
+		lprintf(LOG_NOTICE, "Rollback timeout........[%d sec] ",
+				pCtx->resp.rollbackTimeout*5);
+		lprintf(LOG_NOTICE, "Inaccessibility timeout.[%d sec] \n",
+				pCtx->resp.inaccessTimeout*5);
+	}
+	return HPMFWUPG_SUCCESS;
+}
+
+int
+HpmfwupgGetComponentProperties(struct ipmi_intf *intf,
+		struct HpmfwupgGetComponentPropertiesCtx *pCtx)
+{
+	int rc = HPMFWUPG_SUCCESS;
+	struct ipmi_rs * rsp;
+	struct ipmi_rq req;
+	pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_PICMG;
+	req.msg.cmd = HPMFWUPG_GET_COMPONENT_PROPERTIES;
+	req.msg.data = (unsigned char*)&pCtx->req;
+	req.msg.data_len = sizeof(struct HpmfwupgGetComponentPropertiesReq);
+	rsp = HpmfwupgSendCmd(intf, req, NULL);
+	if (rsp == NULL) {
+		lprintf(LOG_NOTICE,
+				"Error getting component properties\n");
+		return HPMFWUPG_ERROR;
+	}
+	if (rsp->ccode != 0x00) {
+		lprintf(LOG_NOTICE,
+				"Error getting component properties");
+		lprintf(LOG_NOTICE,
+				"compcode=0x%x: %s",
+				rsp->ccode,
+				val2str(rsp->ccode, completion_code_vals));
+		return HPMFWUPG_ERROR;
+	}
+	switch (pCtx->req.selector) {
+	case HPMFWUPG_COMP_GEN_PROPERTIES:
+		memcpy(&pCtx->resp, rsp->data, sizeof(struct HpmfwupgGetGeneralPropResp));
+		if (verbose) {
+			lprintf(LOG_NOTICE, "GENERAL PROPERTIES");
+			lprintf(LOG_NOTICE, "-------------------------------");
+			lprintf(LOG_NOTICE, "Payload cold reset req....[%c]   ",
+					pCtx->resp.Response.generalPropResp.GeneralCompProperties.bitfield.payloadColdReset ? 'y' : 'n');
+			lprintf(LOG_NOTICE, "Def. activation supported.[%c]   ",
+					pCtx->resp.Response.generalPropResp.GeneralCompProperties.bitfield.deferredActivation ? 'y' : 'n');
+			lprintf(LOG_NOTICE, "Comparison supported......[%c]   ",
+					pCtx->resp.Response.generalPropResp.GeneralCompProperties.bitfield.comparisonSupport ? 'y' : 'n');
+			lprintf(LOG_NOTICE, "Preparation supported.....[%c]   ",
+					pCtx->resp.Response.generalPropResp.GeneralCompProperties.bitfield.preparationSupport ? 'y' : 'n');
+			lprintf(LOG_NOTICE, "Rollback supported........[%c]   \n",
+					pCtx->resp.Response.generalPropResp.GeneralCompProperties.bitfield.rollbackBackup ? 'y' : 'n');
+		}
+		break;
+	case HPMFWUPG_COMP_CURRENT_VERSION:
+		memcpy(&pCtx->resp, rsp->data,
+				sizeof(struct HpmfwupgGetCurrentVersionResp));
+		if (verbose) {
+			lprintf(LOG_NOTICE, "Current Version: ");
+			lprintf(LOG_NOTICE, " Major: %d",
+					pCtx->resp.Response.currentVersionResp.currentVersion[0]);
+			lprintf(LOG_NOTICE, " Minor: %x",
+					pCtx->resp.Response.currentVersionResp.currentVersion[1]);
+			lprintf(LOG_NOTICE, " Aux  : %03d %03d %03d %03d\n",
+					pCtx->resp.Response.currentVersionResp.currentVersion[2],
+					pCtx->resp.Response.currentVersionResp.currentVersion[3],
+					pCtx->resp.Response.currentVersionResp.currentVersion[4],
+					pCtx->resp.Response.currentVersionResp.currentVersion[5]);
+		}
+		break;
+	case HPMFWUPG_COMP_DESCRIPTION_STRING:
+		memcpy(&pCtx->resp, rsp->data,
+				sizeof(struct HpmfwupgGetDescStringResp));
+		if (verbose) {
+			char descString[HPMFWUPG_DESC_STRING_LENGTH + 1];
+			memcpy(descString,
+					pCtx->resp.Response.descStringResp.descString,
+					HPMFWUPG_DESC_STRING_LENGTH);
+			descString[HPMFWUPG_DESC_STRING_LENGTH] = '\0';
+			lprintf(LOG_NOTICE,
+					"Description string: %s\n",
+					descString);
+		}
+		break;
+	case HPMFWUPG_COMP_ROLLBACK_FIRMWARE_VERSION:
+		memcpy(&pCtx->resp, rsp->data, sizeof(struct HpmfwupgGetRollbackFwVersionResp));
+		if (verbose) {
+			lprintf(LOG_NOTICE, "Rollback FW Version: ");
+			lprintf(LOG_NOTICE, " Major: %d",
+					pCtx->resp.Response.rollbackFwVersionResp.rollbackFwVersion[0]);
+			lprintf(LOG_NOTICE, " Minor: %x",
+					pCtx->resp.Response.rollbackFwVersionResp.rollbackFwVersion[1]);
+			lprintf(LOG_NOTICE, " Aux  : %03d %03d %03d %03d\n",
+					pCtx->resp.Response.rollbackFwVersionResp.rollbackFwVersion[2],
+					pCtx->resp.Response.rollbackFwVersionResp.rollbackFwVersion[3],
+					pCtx->resp.Response.rollbackFwVersionResp.rollbackFwVersion[4],
+					pCtx->resp.Response.rollbackFwVersionResp.rollbackFwVersion[5]);
+		}
+		break;
+	case HPMFWUPG_COMP_DEFERRED_FIRMWARE_VERSION:
+		memcpy(&pCtx->resp, rsp->data, sizeof(struct HpmfwupgGetDeferredFwVersionResp));
+		if (verbose) {
+			lprintf(LOG_NOTICE, "Deferred FW Version: ");
+			lprintf(LOG_NOTICE, " Major: %d",
+					pCtx->resp.Response.deferredFwVersionResp.deferredFwVersion[0]);
+			lprintf(LOG_NOTICE, " Minor: %x",
+					pCtx->resp.Response.deferredFwVersionResp.deferredFwVersion[1]);
+			lprintf(LOG_NOTICE, " Aux  : %03d %03d %03d %03d\n",
+					pCtx->resp.Response.deferredFwVersionResp.deferredFwVersion[2],
+					pCtx->resp.Response.deferredFwVersionResp.deferredFwVersion[3],
+					pCtx->resp.Response.deferredFwVersionResp.deferredFwVersion[4],
+					pCtx->resp.Response.deferredFwVersionResp.deferredFwVersion[5]);
+		}
+		break;
+	case HPMFWUPG_COMP_OEM_PROPERTIES:
+		/* OEM Properties command */
+		memcpy(&pCtx->resp, rsp->data, sizeof(struct HpmfwupgGetOemProperties));
+		if (verbose) {
+			unsigned char i = 0;
+			lprintf(LOG_NOTICE,"OEM Properties: ");
+			for (i=0; i < HPMFWUPG_OEM_LENGTH; i++) {
+				lprintf(LOG_NOTICE, " 0x%x ",
+						pCtx->resp.Response.oemProperties.oemRspData[i]);
+			}
+		}
+		break;
+	default:
+		lprintf(LOG_NOTICE,"Unsupported component selector");
+		rc = HPMFWUPG_ERROR;
+		break;
+	}
+	return rc;
+}
+
+int
+HpmfwupgAbortUpgrade(struct ipmi_intf *intf,
+		struct HpmfwupgAbortUpgradeCtx *pCtx)
+{
+	int rc = HPMFWUPG_SUCCESS;
+	struct ipmi_rs *rsp;
+	struct ipmi_rq req;
+	pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_PICMG;
+	req.msg.cmd = HPMFWUPG_ABORT_UPGRADE;
+	req.msg.data = (unsigned char*)&pCtx->req;
+	req.msg.data_len = sizeof(struct HpmfwupgAbortUpgradeReq);
+	rsp = HpmfwupgSendCmd(intf, req, NULL);
+	if (rsp == NULL) {
+		lprintf(LOG_ERR, "Error - aborting upgrade.");
+		return HPMFWUPG_ERROR;
+	}
+	if (rsp->ccode != 0x00) {
+		lprintf(LOG_ERR, "Error aborting upgrade");
+		lprintf(LOG_ERR, "compcode=0x%x: %s",
+				rsp->ccode,
+				val2str(rsp->ccode, completion_code_vals));
+		rc = HPMFWUPG_ERROR;
+	}
+	return rc;
+}
+
+int
+HpmfwupgInitiateUpgradeAction(struct ipmi_intf *intf,
+		struct HpmfwupgInitiateUpgradeActionCtx *pCtx,
+		struct HpmfwupgUpgradeCtx *pFwupgCtx)
+{
+	int rc = HPMFWUPG_SUCCESS;
+	struct ipmi_rs *rsp;
+	struct ipmi_rq req;
+	pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_PICMG;
+	req.msg.cmd = HPMFWUPG_INITIATE_UPGRADE_ACTION;
+	req.msg.data = (unsigned char*)&pCtx->req;
+	req.msg.data_len = sizeof(struct HpmfwupgInitiateUpgradeActionReq);
+	rsp = HpmfwupgSendCmd(intf, req, pFwupgCtx);
+	if (rsp == NULL) {
+		lprintf(LOG_ERR, "Error initiating upgrade action.");
+		return HPMFWUPG_ERROR;
+	}
+	/* Long duration command handling */
+	if (rsp->ccode == HPMFWUPG_COMMAND_IN_PROGRESS) {
+		rc = HpmfwupgWaitLongDurationCmd(intf, pFwupgCtx);
+	} else if (rsp->ccode != 0x00) {
+		lprintf(LOG_NOTICE,"Error initiating upgrade action");
+		lprintf(LOG_NOTICE, "compcode=0x%x: %s",
+				rsp->ccode,
+				val2str(rsp->ccode, completion_code_vals));
+		rc = HPMFWUPG_ERROR;
+	}
+	return rc;
+}
+
+int
+HpmfwupgUploadFirmwareBlock(struct ipmi_intf *intf,
+		struct HpmfwupgUploadFirmwareBlockCtx *pCtx,
+		struct HpmfwupgUpgradeCtx *pFwupgCtx, int count,
+		unsigned int *imageOffset, unsigned int *blockLength)
+{
+	int rc = HPMFWUPG_SUCCESS;
+	struct ipmi_rs *rsp;
+	struct ipmi_rq req;
+	pCtx->req->picmgId = HPMFWUPG_PICMG_IDENTIFIER;
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_PICMG;
+	req.msg.cmd = HPMFWUPG_UPLOAD_FIRMWARE_BLOCK;
+	req.msg.data = (unsigned char *)pCtx->req;
+	/* 2 is the size of the upload struct - data */
+	req.msg.data_len = 2 + count;
+	rsp = HpmfwupgSendCmd(intf, req, pFwupgCtx);
+	if (rsp == NULL) {
+		lprintf(LOG_NOTICE, "Error uploading firmware block.");
+		return HPMFWUPG_ERROR;
+	}
+	if (rsp->ccode == HPMFWUPG_COMMAND_IN_PROGRESS
+			|| rsp->ccode == 0x00) {
+		/*
+		 * We need to check if the response also contains the next upload firmware offset
+		 * and the firmware length in its response - These are optional but very vital
+		 */
+		if (rsp->data_len > 1) {
+			/*
+			 * If the response data length is greater than 1 it should contain both the
+			 * the Section offset and section length. Because we cannot just have
+			 * Section offset without section length so the length should be 9
+			 */
+			if (rsp->data_len == 9) {
+				/* rsp->data[1] - LSB  rsp->data[2]  - rsp->data[3] = MSB */
+				*imageOffset = (rsp->data[4] << 24) + (rsp->data[3] << 16) + (rsp->data[2] << 8) + rsp->data[1];
+				*blockLength = (rsp->data[8] << 24) + (rsp->data[7] << 16) + (rsp->data[6] << 8) + rsp->data[5];
+			} else {
+				 /*
+				 * The Spec does not say much for this kind of errors where the
+				 * firmware returned only offset and length so currently returning it
+				 * as 0x82 - Internal CheckSum Error
+				 */
+				lprintf(LOG_NOTICE,
+						"Error wrong rsp->datalen %d for Upload Firmware block command\n",
+						rsp->data_len);
+				rsp->ccode = HPMFWUPG_INT_CHECKSUM_ERROR;
+			}
+		}
+	}
+	/* Long duration command handling */
+	if (rsp->ccode == HPMFWUPG_COMMAND_IN_PROGRESS) {
+		rc = HpmfwupgWaitLongDurationCmd(intf, pFwupgCtx);
+	} else if (rsp->ccode != 0x00)  {
+		/* PATCH --> This validation is to handle retryables errors codes on IPMB bus.
+		 *           This will be fixed in the next release of open ipmi and this
+		 *           check will have to be removed. (Buggy version = 39)
+		 */
+		if (HPMFWUPG_IS_RETRYABLE(rsp->ccode)) {
+			lprintf(LOG_DEBUG, "HPM: [PATCH]Retryable error detected");
+			rc = HPMFWUPG_UPLOAD_RETRY;
+		} else if (rsp->ccode == IPMI_CC_REQ_DATA_INV_LENGTH ||
+				rsp->ccode == IPMI_CC_REQ_DATA_FIELD_EXCEED) {
+			/* If completion code = 0xc7(0xc8), we will retry with a reduced buffer length.
+			 * Do not print error.
+			 */
+			rc = HPMFWUPG_UPLOAD_BLOCK_LENGTH;
+		} else {
+			lprintf(LOG_ERR, "Error uploading firmware block");
+			lprintf(LOG_ERR, "compcode=0x%x: %s",
+					rsp->ccode,
+					val2str(rsp->ccode,
+						completion_code_vals));
+			rc = HPMFWUPG_ERROR;
+		}
+	}
+	return rc;
+}
+
+int
+HpmfwupgFinishFirmwareUpload(struct ipmi_intf *intf,
+		struct HpmfwupgFinishFirmwareUploadCtx *pCtx,
+		struct HpmfwupgUpgradeCtx *pFwupgCtx, int option)
+{
+	int rc = HPMFWUPG_SUCCESS;
+	struct ipmi_rs *rsp;
+	struct ipmi_rq req;
+	pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_PICMG;
+	req.msg.cmd = HPMFWUPG_FINISH_FIRMWARE_UPLOAD;
+	req.msg.data = (unsigned char*)&pCtx->req;
+	req.msg.data_len = sizeof(struct HpmfwupgFinishFirmwareUploadReq);
+	rsp = HpmfwupgSendCmd(intf, req, pFwupgCtx);
+	if (rsp == NULL) {
+		lprintf(LOG_ERR, "Error fininshing firmware upload.");
+		return HPMFWUPG_ERROR;
+	}
+	/* Long duration command handling */
+	if (rsp->ccode == HPMFWUPG_COMMAND_IN_PROGRESS) {
+		rc = HpmfwupgWaitLongDurationCmd(intf, pFwupgCtx);
+	} else if ((option & COMPARE_MODE) && rsp->ccode == 0x83) {
+		printf("|    |Component's active copy doesn't match the upgrade image                 |\n");
+	} else if ((option & COMPARE_MODE) && rsp->ccode == IPMI_CC_OK) {
+		printf("|    |Comparison passed                                                       |\n");
+	} else if ( rsp->ccode != IPMI_CC_OK ) {
+		lprintf(LOG_ERR, "Error finishing firmware upload");
+		lprintf(LOG_ERR, "compcode=0x%x: %s",
+				rsp->ccode,
+				val2str(rsp->ccode, completion_code_vals));
+		rc = HPMFWUPG_ERROR;
+	}
+	return rc;
+}
+
+int
+HpmfwupgActivateFirmware(struct ipmi_intf *intf,
+		struct HpmfwupgActivateFirmwareCtx *pCtx,
+		struct HpmfwupgUpgradeCtx *pFwupgCtx)
+{
+	int rc = HPMFWUPG_SUCCESS;
+	struct ipmi_rs *rsp;
+	struct ipmi_rq req;
+	pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_PICMG;
+	req.msg.cmd = HPMFWUPG_ACTIVATE_FIRMWARE;
+	req.msg.data = (unsigned char*)&pCtx->req;
+	req.msg.data_len = sizeof(struct HpmfwupgActivateFirmwareReq)
+		- (!pCtx->req.rollback_override ? 1 : 0);
+	rsp = HpmfwupgSendCmd(intf, req, pFwupgCtx);
+	if (rsp == NULL) {
+		lprintf(LOG_ERR, "Error activating firmware.");
+		return HPMFWUPG_ERROR;
+	}
+	/* Long duration command handling */
+	if (rsp->ccode == HPMFWUPG_COMMAND_IN_PROGRESS) {
+		printf("Waiting firmware activation...");
+		fflush(stdout);
+		rc = HpmfwupgWaitLongDurationCmd(intf, pFwupgCtx);
+		if (rc == HPMFWUPG_SUCCESS) {
+			lprintf(LOG_NOTICE, "OK");
+		} else {
+			lprintf(LOG_NOTICE, "Failed");
+		}
+	} else if (rsp->ccode != IPMI_CC_OK) {
+		lprintf(LOG_ERR, "Error activating firmware");
+		lprintf(LOG_ERR, "compcode=0x%x: %s",
+				rsp->ccode,
+				val2str(rsp->ccode, completion_code_vals));
+		rc = HPMFWUPG_ERROR;
+	}
+	return rc;
+}
+
+int
+HpmfwupgGetUpgradeStatus(struct ipmi_intf *intf,
+		struct HpmfwupgGetUpgradeStatusCtx *pCtx,
+		struct HpmfwupgUpgradeCtx *pFwupgCtx,
+		int silent)
+{
+	int rc = HPMFWUPG_SUCCESS;
+	struct ipmi_rs *rsp;
+	struct ipmi_rq req;
+	pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_PICMG;
+	req.msg.cmd = HPMFWUPG_GET_UPGRADE_STATUS;
+	req.msg.data = (unsigned char*)&pCtx->req;
+	req.msg.data_len = sizeof(struct HpmfwupgGetUpgradeStatusReq);
+	rsp = HpmfwupgSendCmd(intf, req, pFwupgCtx);
+	if (!rsp) {
+		lprintf(LOG_NOTICE,
+				"Error getting upgrade status. Failed to get response.");
+		return HPMFWUPG_ERROR;
+	}
+	if (rsp->ccode == 0x00) {
+		memcpy(&pCtx->resp, rsp->data, 
+				sizeof(struct HpmfwupgGetUpgradeStatusResp));
+		if (!silent) {
+			lprintf(LOG_NOTICE, "Upgrade status:");
+			lprintf(LOG_NOTICE,
+					" Command in progress:          %x",
+					pCtx->resp.cmdInProcess);
+			lprintf(LOG_NOTICE,
+					" Last command completion code: %x",
+					pCtx->resp.lastCmdCompCode);
+		}
+	} else if (HPMFWUPG_IS_RETRYABLE(rsp->ccode)) {
+		/* PATCH --> This validation is to handle retryable errors 
+		 *           codes on the IPMB bus.
+		 *           This will be fixed in the next release of 
+		 *           open ipmi and this check can be removed. 
+		 *           (Buggy version = 39)
+		 */
+		if (!silent) {
+			lprintf(LOG_DEBUG, "HPM: Retryable error detected");
+		}
+		pCtx->resp.lastCmdCompCode = HPMFWUPG_COMMAND_IN_PROGRESS;
+	} else {
+		lprintf(LOG_NOTICE, "Error getting upgrade status");
+		lprintf(LOG_NOTICE, "compcode=0x%x: %s", rsp->ccode,
+				val2str(rsp->ccode, completion_code_vals));
+		return HPMFWUPG_ERROR;
+	}
+	return HPMFWUPG_SUCCESS;
+}
+
+int
+HpmfwupgManualFirmwareRollback(struct ipmi_intf *intf,
+		struct HpmfwupgManualFirmwareRollbackCtx *pCtx)
+{
+	struct HpmfwupgUpgradeCtx fwupgCtx;
+	struct HpmfwupgGetTargetUpgCapabilitiesCtx targetCapCmd;
+	int rc = HPMFWUPG_SUCCESS;
+	struct ipmi_rs *rsp;
+	struct ipmi_rq req;
+	/* prepare fake upgrade context */
+	memset(&fwupgCtx, 0, sizeof (fwupgCtx));
+	verbose--;
+	rc = HpmfwupgGetTargetUpgCapabilities(intf, &targetCapCmd);
+	verbose++;
+	if (rc != HPMFWUPG_SUCCESS) {
+		return rc;
+	}
+	memcpy(&fwupgCtx.targetCap, &targetCapCmd.resp, sizeof(targetCapCmd.resp));
+	pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_PICMG;
+	req.msg.cmd = HPMFWUPG_MANUAL_FIRMWARE_ROLLBACK;
+	req.msg.data = (unsigned char*)&pCtx->req;
+	req.msg.data_len = sizeof(struct HpmfwupgManualFirmwareRollbackReq);
+	rsp = HpmfwupgSendCmd(intf, req, &fwupgCtx);
+	if (rsp == NULL) {
+		lprintf(LOG_ERR, "Error sending manual rollback.");
+		return HPMFWUPG_ERROR;
+	}
+	/* Long duration command handling */
+	if (rsp->ccode == IPMI_CC_OK
+			|| rsp->ccode == HPMFWUPG_COMMAND_IN_PROGRESS) {
+		struct HpmfwupgQueryRollbackStatusCtx resCmd;
+		printf("Waiting firmware rollback...");
+		fflush(stdout);
+		rc = HpmfwupgQueryRollbackStatus(intf, &resCmd, &fwupgCtx);
+	} else if ( rsp->ccode != 0x00 ) {
+		lprintf(LOG_ERR, "Error sending manual rollback");
+		lprintf(LOG_ERR, "compcode=0x%x: %s",  
+				rsp->ccode,
+				val2str(rsp->ccode, completion_code_vals));
+		rc = HPMFWUPG_ERROR;
+	}
+	return rc;
+}
+
+int
+HpmfwupgQueryRollbackStatus(struct ipmi_intf *intf,
+		struct HpmfwupgQueryRollbackStatusCtx *pCtx,
+		struct HpmfwupgUpgradeCtx *pFwupgCtx)
+{
+	int rc = HPMFWUPG_SUCCESS;
+	struct ipmi_rs *rsp;
+	struct ipmi_rq req;
+	unsigned int rollbackTimeout = 0;
+	unsigned int timeoutSec1, timeoutSec2;
+	pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_PICMG;
+	req.msg.cmd = HPMFWUPG_QUERY_ROLLBACK_STATUS;
+	req.msg.data = (unsigned char*)&pCtx->req;
+	req.msg.data_len = sizeof(struct HpmfwupgQueryRollbackStatusReq);
+	/* If we are not in upgrade context, we use default timeout values */
+	if (pFwupgCtx != NULL) {
+		struct HpmfwupgImageHeader *pImageHeader;
+		if (pFwupgCtx->pImageData) {
+			pImageHeader = (struct HpmfwupgImageHeader*)pFwupgCtx->pImageData;
+			rollbackTimeout = pImageHeader->rollbackTimeout;
+		} else {
+			rollbackTimeout = 0;
+		}
+		/* Use the greater of the two timeouts (header and target caps) */
+		rollbackTimeout = MAX(rollbackTimeout,
+				pFwupgCtx->targetCap.rollbackTimeout) * 5;
+	} else {
+		rollbackTimeout = HPMFWUPG_DEFAULT_UPGRADE_TIMEOUT;
+	}
+	/* Poll rollback status until completion or timeout */
+	timeoutSec1 = time(NULL);
+	timeoutSec2 = time(NULL);
+	do {
+		/* Must wait at least 100 ms between status requests */
+		usleep(100000);
+		rsp = HpmfwupgSendCmd(intf, req, pFwupgCtx);
+		/* PATCH --> This validation is to handle retryables errors codes on IPMB bus.
+		 *           This will be fixed in the next release of open ipmi and this
+		 *           check will have to be removed. (Buggy version = 39)
+		 */
+		if (rsp) {
+			if (HPMFWUPG_IS_RETRYABLE(rsp->ccode)) {
+				lprintf(LOG_DEBUG,"HPM: [PATCH]Retryable error detected");
+				rsp->ccode = HPMFWUPG_COMMAND_IN_PROGRESS;
+			}
+		}
+		timeoutSec2 = time(NULL);
+	} while (rsp
+			&& ((rsp->ccode == HPMFWUPG_COMMAND_IN_PROGRESS)
+				|| (rsp->ccode == IPMI_CC_TIMEOUT))
+			&& (timeoutSec2 - timeoutSec1 < rollbackTimeout));
+	if (rsp == NULL) {
+		lprintf(LOG_ERR, "Error getting upgrade status.");
+		return HPMFWUPG_ERROR;
+	}
+	if (rsp->ccode == 0x00) {
+		memcpy(&pCtx->resp, rsp->data,
+				sizeof(struct HpmfwupgQueryRollbackStatusResp));
+		if (pCtx->resp.rollbackComp.ComponentBits.byte != 0) {
+			/* Rollback occured */
+			lprintf(LOG_NOTICE,
+					"Rollback occured on component mask: 0x%02x",
+					pCtx->resp.rollbackComp.ComponentBits.byte);
+		} else {
+			lprintf(LOG_NOTICE,
+					"No Firmware rollback occured");
+		}
+	} else if (rsp->ccode == 0x81) {
+		lprintf(LOG_ERR,
+				"Rollback failed on component mask: 0x%02x",
+				pCtx->resp.rollbackComp.ComponentBits.byte);
+		rc = HPMFWUPG_ERROR;
+	} else {
+		lprintf(LOG_ERR,
+				"Error getting rollback status");
+		lprintf(LOG_ERR,
+				"compcode=0x%x: %s",  
+				rsp->ccode,
+				val2str(rsp->ccode, completion_code_vals));
+		rc = HPMFWUPG_ERROR;
+	}
+	return rc;
+}
+
+int
+HpmfwupgQuerySelftestResult(struct ipmi_intf *intf, struct HpmfwupgQuerySelftestResultCtx *pCtx,
+		struct HpmfwupgUpgradeCtx *pFwupgCtx)
+{
+	int rc = HPMFWUPG_SUCCESS;
+	struct ipmi_rs *rsp;
+	struct ipmi_rq req;
+	unsigned char selfTestTimeout = 0;
+	unsigned int timeoutSec1, timeoutSec2;
+	pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
+	/* If we are not in upgrade context, we use default timeout values */
+	if (pFwupgCtx != NULL) {
+		/* Getting selftest timeout from new image */
+		struct HpmfwupgImageHeader *pImageHeader = (struct HpmfwupgImageHeader*)
+			pFwupgCtx->pImageData;
+		selfTestTimeout = MAX(pImageHeader->selfTestTimeout,
+		pFwupgCtx->targetCap.selftestTimeout) * 5;
+	} else {
+		selfTestTimeout = HPMFWUPG_DEFAULT_UPGRADE_TIMEOUT;
+	}
+	memset(&req, 0, sizeof(req));
+	req.msg.netfn = IPMI_NETFN_PICMG;
+	req.msg.cmd = HPMFWUPG_QUERY_SELFTEST_RESULT;
+	req.msg.data = (unsigned char*)&pCtx->req;
+	req.msg.data_len = sizeof(struct HpmfwupgQuerySelftestResultReq);
+	/* Poll rollback status until completion or timeout */
+	timeoutSec1 = time(NULL);
+	timeoutSec2 = time(NULL);
+	do {
+		/* Must wait at least 100 ms between status requests */
+		usleep(100000);
+		rsp = HpmfwupgSendCmd(intf, req, pFwupgCtx);
+		/* PATCH --> This validation is to handle retryables errors codes on IPMB bus.
+		 *           This will be fixed in the next release of open ipmi and this
+		 *           check will have to be removed. (Buggy version = 39)
+		 */
+		if (rsp) {
+			if (HPMFWUPG_IS_RETRYABLE(rsp->ccode)) {
+				lprintf(LOG_DEBUG,
+						"HPM: [PATCH]Retryable error detected");
+				rsp->ccode = HPMFWUPG_COMMAND_IN_PROGRESS;
+			}
+		}
+		timeoutSec2 = time(NULL);
+	} while (rsp
+			&& (rsp->ccode == HPMFWUPG_COMMAND_IN_PROGRESS)
+			&& (timeoutSec2 - timeoutSec1 < selfTestTimeout));
+	if (rsp == NULL) {
+		lprintf(LOG_NOTICE, "Error getting upgrade status\n");
+		return HPMFWUPG_ERROR;
+	}
+	if (rsp->ccode == 0x00) {
+		memcpy(&pCtx->resp, rsp->data,
+				sizeof(struct HpmfwupgQuerySelftestResultResp));
+		if (verbose) {
+			lprintf(LOG_NOTICE, "Self test results:");
+			lprintf(LOG_NOTICE, "Result1 = %x",
+					pCtx->resp.result1);
+			lprintf(LOG_NOTICE, "Result2 = %x",
+					pCtx->resp.result2);
+		}
+	} else {
+		lprintf(LOG_NOTICE, "Error getting self test results");
+		lprintf(LOG_NOTICE, "compcode=0x%x: %s",
+				rsp->ccode,
+				val2str(rsp->ccode, completion_code_vals));
+		rc = HPMFWUPG_ERROR;
+	}
+	return rc;
+}
+
+struct ipmi_rs *
+HpmfwupgSendCmd(struct ipmi_intf *intf, struct ipmi_rq req,
+		struct HpmfwupgUpgradeCtx *pFwupgCtx)
+{
+	struct ipmi_rs *rsp;
+	unsigned int inaccessTimeout = 0, inaccessTimeoutCounter = 0;
+	unsigned int upgradeTimeout  = 0, upgradeTimeoutCounter  = 0;
+	unsigned int  timeoutSec1, timeoutSec2;
+	unsigned char retry = 0;
+	/* If we are not in upgrade context, we use default timeout values */
+	if (pFwupgCtx != NULL) {
+		inaccessTimeout = pFwupgCtx->targetCap.inaccessTimeout*5;
+		upgradeTimeout  = pFwupgCtx->targetCap.upgradeTimeout*5;
+	} else {
+		/* keeping the inaccessTimeout to 60 seconds results in almost 2900 retries
+		 * So if the target is not available it will be retrying the command for 2900
+		 * times which is not effecient -So reducing the Timout to 5 seconds which is
+		 * almost 200 retries if it continuously recieves 0xC3 as completion code.
+		 */
+		inaccessTimeout = HPMFWUPG_DEFAULT_UPGRADE_TIMEOUT;
+		upgradeTimeout  = HPMFWUPG_DEFAULT_UPGRADE_TIMEOUT;
+	}
+	timeoutSec1 = time(NULL);
+	do {
+		static unsigned char isValidSize = FALSE;
+		rsp = intf->sendrecv(intf, &req);
+		if (rsp == NULL) {
+			#define HPM_LAN_PACKET_RESIZE_LIMIT 6
+			/* also covers lanplus */
+			if (strstr(intf->name, "lan") != NULL) {
+				static int errorCount=0;
+				static struct ipmi_rs fakeRsp;
+				lprintf(LOG_DEBUG,
+						"HPM: no response available");
+				lprintf(LOG_DEBUG,
+						"HPM: the command may be rejected for security reasons");
+				if (req.msg.netfn == IPMI_NETFN_PICMG
+						&& req.msg.cmd == HPMFWUPG_UPLOAD_FIRMWARE_BLOCK
+						&& errorCount < HPM_LAN_PACKET_RESIZE_LIMIT
+						&& (!isValidSize)) {
+					lprintf(LOG_DEBUG,
+							"HPM: upload firmware block API called");
+					lprintf(LOG_DEBUG,
+							"HPM: returning length error to force resize");
+					fakeRsp.ccode = IPMI_CC_REQ_DATA_INV_LENGTH;
+					rsp = &fakeRsp;
+					errorCount++;
+				} else if (req.msg.netfn == IPMI_NETFN_PICMG
+						&& (req.msg.cmd == HPMFWUPG_ACTIVATE_FIRMWARE
+							|| req.msg.cmd == HPMFWUPG_MANUAL_FIRMWARE_ROLLBACK)) {
+					/*
+					 * rsp == NULL and command activate firmware or manual firmware
+					 * rollback most likely occurs when we have sent a firmware activation
+					 * request. Fake a command in progress response.
+					 */
+					lprintf(LOG_DEBUG,
+							"HPM: activate/rollback firmware API called");
+					lprintf(LOG_DEBUG,
+							"HPM: returning in progress to handle IOL session lost");
+					fakeRsp.ccode = HPMFWUPG_COMMAND_IN_PROGRESS;
+					rsp = &fakeRsp;
+				} else if (req.msg.netfn == IPMI_NETFN_PICMG
+						&& (req.msg.cmd == HPMFWUPG_QUERY_ROLLBACK_STATUS
+							|| req.msg.cmd == HPMFWUPG_GET_UPGRADE_STATUS
+							|| req.msg.cmd == HPMFWUPG_QUERY_SELFTEST_RESULT)
+						&& ( !intf->target_addr || intf->target_addr == intf->my_addr)) {
+					/* reopen session only if target IPMC is directly accessed */
+					/*
+					 * rsp == NULL and command get upgrade status or query rollback
+					 * status most likely occurs when we are waiting for firmware
+					 * activation. Try to re-open the IOL session (re-open will work
+					 * once the IPMC recovers from firmware activation.
+					 */
+					lprintf(LOG_DEBUG, "HPM: upg/rollback status firmware API called");
+					lprintf(LOG_DEBUG, "HPM: try to re-open IOL session");
+					{
+						/* force session re-open */
+						intf->opened = 0;
+						intf->session->authtype = IPMI_SESSION_AUTHTYPE_NONE;
+						intf->session->session_id = 0;
+						intf->session->in_seq = 0;
+						intf->session->out_seq = 0;
+						intf->session->active = 0;
+						intf->session->retry = 10;
+						while (intf->open(intf) == HPMFWUPG_ERROR
+								&& inaccessTimeoutCounter < inaccessTimeout) {
+							inaccessTimeoutCounter += (time(NULL) - timeoutSec1);
+							timeoutSec1 = time(NULL);
+						}
+						/* Fake timeout to retry command */
+						fakeRsp.ccode = 0xc3;
+						rsp = &fakeRsp;
+					}
+				}
+			}
+		}
+		/* Handle inaccessibility timeout (rsp = NULL if IOL) */
+		if (rsp == NULL || rsp->ccode == 0xff || rsp->ccode == 0xc3 || rsp->ccode == 0xd3) {
+			if (inaccessTimeoutCounter < inaccessTimeout) {
+				timeoutSec2 = time(NULL);
+				if (timeoutSec2 > timeoutSec1) {
+					inaccessTimeoutCounter += timeoutSec2 - timeoutSec1;
+					timeoutSec1 = time(NULL);
+				}
+				usleep(100000);
+				retry = 1;
+			} else {
+				retry = 0;
+			}
+		} else if ( rsp->ccode == 0xc0 ) {
+			/* Handle node busy timeout */
+			if (upgradeTimeoutCounter < upgradeTimeout) {
+				timeoutSec2 = time(NULL);
+				if (timeoutSec2 > timeoutSec1) {
+					timeoutSec1 = time(NULL);
+					upgradeTimeoutCounter += timeoutSec2 - timeoutSec1;
+				}
+				usleep(100000);
+				retry = 1;
+			} else {
+				retry = 0;
+			}
+		} else {
+# ifdef ENABLE_OPENIPMI_V39_PATCH
+			if (rsp->ccode == IPMI_CC_OK) {
+				errorCount = 0 ;
+			}
+# endif
+			retry = 0;
+			if (req.msg.netfn == IPMI_NETFN_PICMG
+					&& req.msg.cmd == HPMFWUPG_UPLOAD_FIRMWARE_BLOCK
+					&& (!isValidSize)) {
+				lprintf(LOG_INFO,
+						"Buffer length is now considered valid");
+				isValidSize = TRUE;
+			}
+		}
+	} while (retry);
+	return rsp;
+}
+
+int
+HpmfwupgWaitLongDurationCmd(struct ipmi_intf *intf,
+		struct HpmfwupgUpgradeCtx *pFwupgCtx)
+{
+	int rc = HPMFWUPG_SUCCESS;
+	unsigned int upgradeTimeout = 0;
+	unsigned int  timeoutSec1, timeoutSec2;
+	struct HpmfwupgGetUpgradeStatusCtx upgStatusCmd;
+	/* If we are not in upgrade context, we use default timeout values */
+	if (pFwupgCtx != NULL) {
+		upgradeTimeout = (unsigned int)(pFwupgCtx->targetCap.upgradeTimeout*5);
+		if (verbose) {
+			printf("Use File Upgrade Capabilities: %i seconds\n",
+					upgradeTimeout);
+		}
+	} else {
+		/* Try to retreive from Caps */
+		struct HpmfwupgGetTargetUpgCapabilitiesCtx targetCapCmd;
+		if(HpmfwupgGetTargetUpgCapabilities(intf, &targetCapCmd) != HPMFWUPG_SUCCESS) {
+			upgradeTimeout = HPMFWUPG_DEFAULT_UPGRADE_TIMEOUT;
+			if (verbose) {
+				printf("Use default timeout: %i seconds\n",
+						upgradeTimeout);
+			}
+		} else {
+			upgradeTimeout = (unsigned int)(targetCapCmd.resp.upgradeTimeout * 5);
+			if (verbose) {
+				printf("Use Command Upgrade Capabilities Timeout: %i seconds\n",
+						upgradeTimeout);
+			}
+		}
+	}
+	if (rc == HPMFWUPG_SUCCESS) {
+		/* Poll upgrade status until completion or timeout*/
+		timeoutSec1 = time(NULL);
+		timeoutSec2 = time(NULL);
+		rc = HpmfwupgGetUpgradeStatus(intf, &upgStatusCmd,
+				pFwupgCtx, 1);
+	}
+	while (
+			/* With KCS: Cover the case where we sometime
+			 * receive d5 (on the first get status) from
+			 * the ipmi driver.
+			 */
+			(upgStatusCmd.resp.lastCmdCompCode != 0x00 )
+			&& ((timeoutSec2 - timeoutSec1) < upgradeTimeout )
+			&& (rc == HPMFWUPG_SUCCESS)) {
+		/* Must wait at least 1000 ms between status requests */
+		usleep(1000000);
+		timeoutSec2 = time(NULL);
+		rc = HpmfwupgGetUpgradeStatus(intf, &upgStatusCmd, pFwupgCtx, 1);
+/*
+ *		printf("Get Status: %x - %x = %x _ %x [%x]\n",
+ (				timeoutSec2, timeoutSec1,
+ *				(timeoutSec2 - timeoutSec1),
+ *				upgradeTimeout, rc);
+ */
+	}
+	if (upgStatusCmd.resp.lastCmdCompCode != 0x00) {
+		if (verbose) {
+			lprintf(LOG_NOTICE,
+					"Error waiting for command %x, compcode = %x",
+					upgStatusCmd.resp.cmdInProcess,
+					upgStatusCmd.resp.lastCmdCompCode);
+		}
+		rc = HPMFWUPG_ERROR;
+	}
+	return rc;
+}
+
+unsigned char
+HpmfwupgCalculateChecksum(unsigned char *pData, unsigned int length)
+{
+	unsigned char checksum = 0;
+	int dataIdx = 0;
+	for (dataIdx = 0; dataIdx < length; dataIdx++) {
+		checksum += pData[dataIdx];
+	}
+	return checksum;
+}
+
+void
+HpmfwupgPrintUsage(void)
+{
+	lprintf(LOG_NOTICE,
+"help                    - This help menu.");
+	lprintf(LOG_NOTICE,
+"");
+	lprintf(LOG_NOTICE,
+"check                   - Check the target information.");
+	lprintf(LOG_NOTICE,
+"check <file>            - If the user is unsure of what update is going to be ");
+	lprintf(LOG_NOTICE,
+"                          This will display the existing target version and");
+	lprintf(LOG_NOTICE,
+"                          image version on the screen");
+	lprintf(LOG_NOTICE,
+"");
+	lprintf(LOG_NOTICE,
+"upgrade <file> [component x...] [force] [activate]");
+	lprintf(LOG_NOTICE,
+"                        - Copies components from a valid HPM.1 image to the target.");
+	lprintf(LOG_NOTICE,
+"                          If one or more components specified by \"component\",");
+	lprintf(LOG_NOTICE,
+"                          only the specified components are copied.");
+	lprintf(LOG_NOTICE,
+"                          Otherwise, all the image components are copied.");
+	lprintf(LOG_NOTICE,
+"                          Before copy, each image component undergoes a version check");
+	lprintf(LOG_NOTICE,
+"                          and can be skipped if the target component version");
+	lprintf(LOG_NOTICE,
+"                          is the same or more recent.");
+	lprintf(LOG_NOTICE,
+"                          Use \"force\" to bypass the version check results.");
+	lprintf(LOG_NOTICE,
+"                          Make sure to check the versions first using the");
+	lprintf(LOG_NOTICE,
+"                          \"check <file>\" command.");
+	lprintf(LOG_NOTICE,
+"                          If \"activate\" is specified, the newly uploaded firmware");
+	lprintf(LOG_NOTICE,
+"                          is activated.");
+	lprintf(LOG_NOTICE,
+"upgstatus               - Returns the status of the last long duration command.");
+	lprintf(LOG_NOTICE,
+"");
+	lprintf(LOG_NOTICE,
+"compare <file>          - Perform \"Comparison of the Active Copy\" action for all the");
+	lprintf(LOG_NOTICE,
+"                          components present in the file.");
+	lprintf(LOG_NOTICE,
+"compare <file> component x - Compare only component <x> from the given <file>");
+	lprintf(LOG_NOTICE,
+"activate                - Activate the newly uploaded firmware.");
+	lprintf(LOG_NOTICE,
+"activate norollback     - Activate the newly uploaded firmware but inform");
+	lprintf(LOG_NOTICE,
+"                          the target to not automatically rollback if ");
+	lprintf(LOG_NOTICE,
+"                          the upgrade fails.");
+	lprintf(LOG_NOTICE,
+"");
+	lprintf(LOG_NOTICE,
+"targetcap               - Get the target upgrade capabilities.");
+	lprintf(LOG_NOTICE,
+"");
+	lprintf(LOG_NOTICE,
+"compprop <id> <prop>    - Get specified component properties from the target.");
+	lprintf(LOG_NOTICE,
+"                          Valid component <id>: 0-7 ");
+	lprintf(LOG_NOTICE,
+"                          Properties <prop> can be one of the following: ");
+	lprintf(LOG_NOTICE,
+"                          0- General properties");
+	lprintf(LOG_NOTICE,
+"                          1- Current firmware version");
+	lprintf(LOG_NOTICE,
+"                          2- Description string");
+	lprintf(LOG_NOTICE,
+"                          3- Rollback firmware version");
+	lprintf(LOG_NOTICE,
+"                          4- Deferred firmware version");
+	lprintf(LOG_NOTICE,
+"");
+	lprintf(LOG_NOTICE,
+"abort                   - Abort the on-going firmware upgrade.");
+	lprintf(LOG_NOTICE,
+"");
+	lprintf(LOG_NOTICE,
+"rollback                - Performs a manual rollback on the IPM Controller.");
+	lprintf(LOG_NOTICE,
+"                          firmware");
+	lprintf(LOG_NOTICE,
+"rollbackstatus          - Query the rollback status.");
+	lprintf(LOG_NOTICE,
+"");
+	lprintf(LOG_NOTICE,
+"selftestresult          - Query the self test results.\n");
+}
+
+int
+ipmi_hpmfwupg_main(struct ipmi_intf *intf, int argc, char **argv)
+{
+	int rc = HPMFWUPG_SUCCESS;
+	int activateFlag = 0x00;
+	int componentMask = 0;
+	int componentId = 0;
+	int option = 0;
+
+	lprintf(LOG_DEBUG,"ipmi_hpmfwupg_main()");
+	lprintf(LOG_NOTICE, "\nPICMG HPM.1 Upgrade Agent %d.%d.%d: \n",
+			HPMFWUPG_VERSION_MAJOR, HPMFWUPG_VERSION_MINOR,
+			HPMFWUPG_VERSION_SUBMINOR);
+	if (argc < 1) {
+		lprintf(LOG_ERR, "Not enough parameters given.");
+		HpmfwupgPrintUsage();
+		return HPMFWUPG_ERROR;
+	}
+	if (strcmp(argv[0], "help") == 0) {
+		HpmfwupgPrintUsage();
+		return HPMFWUPG_SUCCESS;
+	} else if ((strcmp(argv[0], "check") == 0)) {
+		/* hpm check */
+		if (argv[1] == NULL) {
+			rc = HpmfwupgTargetCheck(intf,VIEW_MODE);
+		} else {
+			/* hpm check <filename> */
+			rc = HpmfwupgTargetCheck(intf,0);
+			if (rc == HPMFWUPG_SUCCESS) {
+				rc = HpmfwupgUpgrade(intf, argv[1], 0,
+						0, VIEW_MODE);
+			}
+		}
+	} else if (strcmp(argv[0], "upgrade") == 0) {
+		int i =0;
+		for (i=1; i< argc ; i++) {
+			if (strcmp(argv[i],"activate") == 0) {
+				activateFlag = 1;
+			}
+			/* hpm upgrade <filename> force */
+			if (strcmp(argv[i],"force") == 0) {
+				option |= FORCE_MODE;
+			}
+			/* hpm upgrade <filename> component <comp Id> */
+			if (strcmp(argv[i],"component") == 0) {
+				if (i+1 < argc) {
+					/* Error Checking */
+					if (str2int(argv[i+1], &componentId) != 0
+							|| componentId < 0
+							|| componentId > HPMFWUPG_COMPONENT_ID_MAX) {
+						lprintf(LOG_ERR,
+								"Given Component ID '%s' is invalid.",
+								argv[i+1]);
+						lprintf(LOG_ERR,
+								"Valid Compoment ID is: <0..7>");
+						return HPMFWUPG_ERROR;
+					}
+					if( verbose ) {
+						lprintf(LOG_NOTICE,
+								"Component Id %d provided",
+								componentId );
+					}
+					componentMask |= 1 << componentId;
+				} else {
+					/* That indicates the user has
+					 * given component on console but
+					 * not given any ID
+					 */
+					lprintf(LOG_NOTICE,
+							"No component Id provided\n");
+					return  HPMFWUPG_ERROR;
+				}
+			}
+			if (strcmp(argv[i],"debug") == 0) {
+				option |= DEBUG_MODE;
+			}
+		}
+		rc = HpmfwupgTargetCheck(intf, 0);
+		if (rc == HPMFWUPG_SUCCESS) {
+			/* Call the Upgrade function to start the upgrade */
+			rc = HpmfwupgUpgrade(intf, argv[1], activateFlag,
+					componentMask, option);
+		}
+	} else if (strcmp(argv[0], "compare") == 0) {
+		int i = 0;
+		for (i=1; i< argc; i++) {
+			/* hpm compare <file> [component x...] */
+			if (strcmp(argv[i],"component") == 0) {
+				if (i+1 < argc) {
+					/* Error Checking */
+					if (str2int(argv[i+1], &componentId) != 0
+							|| componentId < 0
+							|| componentId > HPMFWUPG_COMPONENT_ID_MAX) {
+						lprintf(LOG_ERR,
+								"Given Component ID '%s' is invalid.",
+								argv[i+1]);
+						lprintf(LOG_ERR,
+								"Valid Compoment ID is: <0..7>");
+						return HPMFWUPG_ERROR;
+					}
+					if( verbose ) {
+						lprintf(LOG_NOTICE,
+								"Component Id %d provided",
+								componentId);
+					}
+					componentMask|= 1 << componentId;
+				} else {
+					/* That indicates the user
+					 * has given component on
+					 * console but not
+					 * given any ID
+					 */
+					lprintf(LOG_NOTICE,
+							"No component Id provided\n");
+					return  HPMFWUPG_ERROR;
+				}
+			} else if (strcmp(argv[i],"debug") == 0) {
+				option|= DEBUG_MODE;
+			}
+		}
+		option|= (COMPARE_MODE);
+		rc = HpmfwupgTargetCheck(intf, 0);
+		if (rc == HPMFWUPG_SUCCESS) {
+			rc = HpmfwupgUpgrade(intf, argv[1], 0,
+					componentMask, option);
+		}
+	} else if ((argc >= 1) && (strcmp(argv[0], "activate") == 0)) {
+		struct HpmfwupgActivateFirmwareCtx cmdCtx;
+		if ((argc == 2) && (strcmp(argv[1], "norollback") == 0)) {
+			cmdCtx.req.rollback_override = 1;
+		} else {
+			cmdCtx.req.rollback_override = 0;
+		}
+		rc = HpmfwupgActivateFirmware(intf, &cmdCtx, NULL);
+	} else if ((argc == 1) && (strcmp(argv[0], "targetcap") == 0)) {
+		struct HpmfwupgGetTargetUpgCapabilitiesCtx cmdCtx;
+		verbose++;
+		rc = HpmfwupgGetTargetUpgCapabilities(intf, &cmdCtx);
+	} else if ((argc == 3) && (strcmp(argv[0], "compprop") == 0)) {
+		struct HpmfwupgGetComponentPropertiesCtx cmdCtx;
+		if (str2uchar(argv[1], &(cmdCtx.req.componentId)) != 0
+				|| cmdCtx.req.componentId > 7) {
+			lprintf(LOG_ERR,
+					"Given Component ID '%s' is invalid.",
+					argv[1]);
+			lprintf(LOG_ERR,
+					"Valid Compoment ID is: <0..7>");
+			return (-1);
+		}
+		if (str2uchar(argv[2], &(cmdCtx.req.selector)) != 0
+				|| cmdCtx.req.selector > 4) {
+			lprintf(LOG_ERR,
+					"Given Properties selector '%s' is invalid.",
+					argv[2]);
+			lprintf(LOG_ERR,
+					"Valid Properties selector is: <0..4>");
+			return (-1);
+		}
+		verbose++;
+		rc = HpmfwupgGetComponentProperties(intf, &cmdCtx);
+	} else if ((argc == 1) && (strcmp(argv[0], "abort") == 0)) {
+		struct HpmfwupgAbortUpgradeCtx cmdCtx;
+		verbose++;
+		rc = HpmfwupgAbortUpgrade(intf, &cmdCtx);
+	} else if ((argc == 1) && (strcmp(argv[0], "upgstatus") == 0)) {
+		struct HpmfwupgGetUpgradeStatusCtx cmdCtx;
+		verbose++;
+		rc = HpmfwupgGetUpgradeStatus(intf, &cmdCtx, NULL, 0);
+	} else if ((argc == 1) && (strcmp(argv[0], "rollback") == 0)) {
+		struct HpmfwupgManualFirmwareRollbackCtx cmdCtx;
+		verbose++;
+		rc = HpmfwupgManualFirmwareRollback(intf, &cmdCtx);
+	} else if ((argc == 1) && (strcmp(argv[0], "rollbackstatus") == 0)) {
+		struct HpmfwupgQueryRollbackStatusCtx  cmdCtx;
+		verbose++;
+		rc = HpmfwupgQueryRollbackStatus(intf, &cmdCtx, NULL);
+	} else if ((argc == 1) && (strcmp(argv[0], "selftestresult") == 0)) {
+		struct HpmfwupgQuerySelftestResultCtx cmdCtx;
+		verbose++;
+		rc = HpmfwupgQuerySelftestResult(intf, &cmdCtx, NULL);
+	} else {
+		lprintf(LOG_ERR, "Invalid HPM command: %s", argv[0]);
+		HpmfwupgPrintUsage();
+		rc = HPMFWUPG_ERROR;
+	}
+	return rc;
+}
+