Merge tag 'upstream/1.8.14'

Upstream version 1.8.14

1 files changed, 1044 insertions, 0 deletions

diff --git a/lib/ipmi_ime.c b/lib/ipmi_ime.c
new file mode 100755
index 0000000..b520ce5
--- /dev/null
+++ b/lib/ipmi_ime.c
@@ -0,0 +1,1044 @@
+/*
+ * Copyright (c) 2007 Kontron Canada, Inc.  All Rights Reserved.
+ *
+ * Base on code from
+ * 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.
+ */
+
+/****************************************************************************
+*
+*       Copyright (c) 2009 Kontron Canada, Inc.  All Rights Reserved.
+*
+*                              IME
+*                    Intel Manageability Engine
+*                      Firmware Update Agent
+*
+* The ME is an IPMI-enabled component included in Intel(R) Next Generation
+*  Server Chipset Nehalem-EP platforms.
+*
+* These are a few synonyms for the ME :
+*
+* - Dynamic Power Node Manager
+* - Intelligent Power Node Manager
+* 
+* Consult Intel litterature for more information on this technology.
+*
+* The ME firmware resides on the platform boot flash and contains read only
+* boot code for the ME as well as boot image redundancy support. 
+*
+* This module implements an Upgrade Agent for the ME firwmare. Because the ME 
+* implements IPMI command handling, the agent speaks directly to the ME. In other
+* words, in order the reach the ME, the BMC must implement IPMB bridging.
+*
+* The update is done through IPMI (this is IPMITOOL right !), not HECI.
+*
+* Example: ME available at address 0x88 on IPMI channel 8:
+*   ipmitool  -m 0x20 -t 0x88 -b 8 ime info
+*
+* !! WARNING - You MUST use an image provided by your board vendor. - WARNING !!
+*
+* author:
+*  Jean-Michel.Audet@ca.kontron.com
+*  Francois.Isabelle@ca.kontron.com
+*
+*****************************************************************************/
+/*
+ * HISTORY
+ * ===========================================================================
+ * 2009-04-20
+ *
+ * First public release of Kontron
+ *
+*/
+#include <ipmitool/ipmi_ime.h>
+#include <ipmitool/log.h>
+#include <ipmitool/ipmi_intf.h>
+#include <ipmitool/ipmi_mc.h>
+#include <ipmitool/helper.h>
+#include <ipmitool/ipmi_strings.h>
+
+
+#undef OUTPUT_DEBUG
+
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <time.h>
+
+static const int IME_SUCCESS              = 0;
+static const int IME_ERROR                = -1;
+static const int IME_RESTART              = -2;
+
+#define IME_UPGRADE_BUFFER_SIZE           22
+#define IME_RETRY_COUNT                   5
+
+typedef struct ImeUpdateImageCtx
+{
+   uint32_t   size;
+   uint8_t *  pData;
+   uint8_t    crc8;
+}tImeUpdateImageCtx;
+
+typedef enum eImeState
+{
+   IME_STATE_IDLE                = 0,
+   IME_STATE_UPDATE_REQUESTED    = 1,
+   IME_STATE_UPDATE_IN_PROGRESS  = 2,
+   IME_STATE_SUCCESS             = 3,
+   IME_STATE_FAILED              = 4,
+   IME_STATE_ROLLED_BACK         = 5,
+   IME_STATE_ABORTED             = 6,
+   IME_STATE_INIT_FAILED         = 7
+} tImeStateEnum;
+
+
+typedef enum tImeUpdateType
+{
+   IME_UPDTYPE_NORMAL            = 1,
+   IME_UPDTYPE_MANUAL_ROLLBACK   = 3,
+   IME_UPDTYPE_ABORT             = 4
+} tImeUpdateType;
+
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+typedef struct sImeStatus {
+   uint8_t image_status;
+   tImeStateEnum update_state;
+   uint8_t update_attempt_status;
+   uint8_t rollback_attempt_status;
+   uint8_t update_type;
+   uint8_t dependent_flag;
+   uint8_t free_area_size[4];
+} ATTRIBUTE_PACKING tImeStatus ;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+typedef struct sImeCaps {
+   uint8_t area_supported;
+   uint8_t special_caps;
+} ATTRIBUTE_PACKING tImeCaps ;
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(0)
+#endif
+
+
+static void ImePrintUsage(void);
+static int  ImeGetInfo(struct ipmi_intf *intf);
+static int  ImeUpgrade(struct ipmi_intf *intf, char* imageFilename);
+static int  ImeManualRollback(struct ipmi_intf *intf);
+static int  ImeUpdatePrepare(struct ipmi_intf *intf);
+static int  ImeUpdateOpenArea(struct ipmi_intf *intf);
+static int  ImeUpdateWriteArea(
+                              struct ipmi_intf *intf,
+                              uint8_t sequence, 
+                              uint8_t length, 
+                              uint8_t * pBuf
+                          );
+static int  ImeUpdateCloseArea(
+                              struct ipmi_intf *intf,
+                              uint32_t size, 
+                              uint16_t checksum
+                          );
+
+static int ImeUpdateGetStatus(struct ipmi_intf *intf, tImeStatus *pStatus);
+static int ImeUpdateGetCapabilities(struct ipmi_intf *intf, tImeCaps *pCaps );
+static int  ImeUpdateRegisterUpdate(struct ipmi_intf *intf, tImeUpdateType type);
+
+static int  ImeImageCtxFromFile(
+                                 char * imageFilename, 
+                                 tImeUpdateImageCtx * pImageCtx);
+static int ImeUpdateShowStatus(struct ipmi_intf *intf);
+
+static uint8_t ImeCrc8( uint32_t length, uint8_t * pBuf );
+
+
+static int ImeGetInfo(struct ipmi_intf *intf)
+{
+   int rc = IME_ERROR;
+   struct ipmi_rs * rsp;
+   struct ipmi_rq req;
+   struct ipm_devid_rsp *devid;
+   const char *product=NULL;
+   tImeStatus status;
+   tImeCaps caps;
+
+   memset(&req, 0, sizeof(req));
+   req.msg.netfn = IPMI_NETFN_APP;
+   req.msg.cmd = BMC_GET_DEVICE_ID;
+   req.msg.data_len = 0;
+
+   rsp = intf->sendrecv(intf, &req);
+   if (rsp == NULL) {
+      lprintf(LOG_ERR, "Get Device ID command failed");
+      return IME_ERROR;
+   }
+   if (rsp->ccode > 0) {
+      lprintf(LOG_ERR, "Get Device ID command failed: %s",
+         val2str(rsp->ccode, completion_code_vals));
+      return IME_ERROR;
+   }
+
+   devid = (struct ipm_devid_rsp *) rsp->data;
+
+   lprintf(LOG_DEBUG,"Device ID                 : %i", devid->device_id);
+   lprintf(LOG_DEBUG,"Device Revision           : %i",
+                           devid->device_revision & IPM_DEV_DEVICE_ID_REV_MASK);
+
+   if(
+      (devid->device_id == 0)
+      &&
+      ((devid->device_revision & IPM_DEV_DEVICE_ID_REV_MASK) == 0)
+      &&
+      (
+         (devid->manufacturer_id[0] == 0x57) // Intel
+         &&
+         (devid->manufacturer_id[1] == 0x01) // Intel
+         &&
+         (devid->manufacturer_id[2] == 0x00) // Intel
+      )
+      &&
+      (
+         (devid->product_id[1] == 0x0b)
+         &&
+         (devid->product_id[0] == 0x00)
+      )
+     )
+   {
+      rc = IME_SUCCESS;
+      printf("Manufacturer Name          : %s\n",
+               val2str( (long)IPM_DEV_MANUFACTURER_ID(devid->manufacturer_id), 
+               ipmi_oem_info) );
+
+      printf("Product ID                 : %u (0x%02x%02x)\n",
+         buf2short((uint8_t *)(devid->product_id)),
+         devid->product_id[1], devid->product_id[0]);
+ 
+      product=oemval2str(IPM_DEV_MANUFACTURER_ID(devid->manufacturer_id),
+                      (devid->product_id[1]<<8)+devid->product_id[0],
+                      ipmi_oem_product_info);
+
+      if (product!=NULL) 
+      {
+         printf("Product Name               : %s\n", product);
+      }
+
+      printf("Intel ME Firmware Revision : %x.%02x.%02x.%x%x%x.%x\n",
+            ((devid->fw_rev1 & IPM_DEV_FWREV1_MAJOR_MASK )         ),
+            ((devid->fw_rev2                             ) >>     4),
+            ((devid->fw_rev2                             )  &  0x0f),
+            ((devid->aux_fw_rev[1]                       ) >>     4),
+            ((devid->aux_fw_rev[1]                       )  &  0x0f),
+            ((devid->aux_fw_rev[2]                       ) >>     4),
+            ((devid->aux_fw_rev[2]                       )  &  0x0f)
+      );
+
+      printf("SPS FW IPMI cmd version    : %x.%x\n",
+         devid->aux_fw_rev[0] >>     4,
+         devid->aux_fw_rev[0] &  0x0f);
+
+      lprintf(LOG_DEBUG,"Flags: %xh", devid->aux_fw_rev[3]);
+
+      printf("Current Image Type         : ");
+      switch( (devid->aux_fw_rev[3] & 0x03) )
+      {
+         case 0:
+            printf("Recovery\n");
+         break;
+
+         case 1:
+            printf("Operational Image 1\n");
+         break;
+
+         case 2:
+            printf("Operational Image 2\n");
+         break;
+
+         case 3:
+         default:
+            printf("Unknown\n");
+         break;
+      }
+   }
+   else
+   {
+         printf("Supported ME not found\n");
+   }
+
+   if(rc == IME_SUCCESS)
+   {
+      rc = ImeUpdateGetStatus(intf, &status);
+   
+      if(rc == IME_SUCCESS)
+      {
+         rc = ImeUpdateGetCapabilities(intf, &caps);
+      }
+
+   }
+   
+   if(rc == IME_SUCCESS)
+   {
+      uint8_t newImage  = ((status.image_status >> 1) & 0x01);
+      uint8_t rollImage = ((status.image_status >> 2) & 0x01);
+      uint8_t runArea   = ((status.image_status >> 3) & 0x03);
+      uint8_t rollSup   = ((caps.special_caps   >> 0) & 0x01);
+      uint8_t recovSup  = ((caps.special_caps   >> 1) & 0x01);
+
+      uint8_t operSup   = ((caps.area_supported   >> 1) & 0x01);
+      uint8_t piaSup    = ((caps.area_supported   >> 2) & 0x01);
+      uint8_t sdrSup    = ((caps.area_supported   >> 3) & 0x01);
+
+      printf("\nSupported Area\n");
+      printf("   Operation Code          : %s\n", (operSup ? "Supported" : "Unsupported"));
+      printf("   PIA                     : %s\n", (piaSup ? "Supported" : "Unsupported"));
+      printf("   SDR                     : %s\n", (sdrSup ? "Supported" : "Unsupported"));
+
+      printf("\nSpecial Capabilities\n");
+      printf("   Rollback                : %s\n", (rollSup ? "Supported" : "Unsupported"));
+      printf("   Recovery                : %s\n", (recovSup ? "Supported" : "Unsupported"));
+
+      printf("\nImage Status\n");
+      printf("   Staging (new)           : %s\n", (newImage ? "Valid" : "Invalid"));
+      printf("   Rollback                : %s\n", (rollImage ? "Valid" : "Invalid"));
+      if(runArea == 0)
+         printf("   Running Image Area      : CODE\n");
+      else
+         printf("   Running Image Area      : CODE%d\n", runArea);
+
+  }
+
+   return rc;
+}
+
+
+static int ImeUpgrade(struct ipmi_intf *intf, char* imageFilename)
+{
+   int rc = IME_SUCCESS;
+   tImeUpdateImageCtx imgCtx;
+   tImeStatus imeStatus;
+   time_t start,end,current;
+   
+   time(&start);
+
+   memset(&imgCtx, 0, sizeof(tImeUpdateImageCtx));
+
+   rc = ImeImageCtxFromFile(imageFilename, &imgCtx);
+
+   if(
+      (rc == IME_ERROR) ||
+      (imgCtx.pData == NULL) ||
+      (imgCtx.size == 0)
+     )
+   {
+      return IME_ERROR;
+   }
+
+   ImeUpdateGetStatus(intf,&imeStatus);
+
+   if(rc == IME_SUCCESS)
+   {
+      rc = ImeUpdatePrepare(intf);
+      ImeUpdateGetStatus(intf,&imeStatus);
+   }
+
+   if(
+      (rc == IME_SUCCESS) &&
+      (imeStatus.update_state == IME_STATE_UPDATE_REQUESTED) 
+     )
+   {
+      rc = ImeUpdateOpenArea(intf);
+      ImeUpdateGetStatus(intf,&imeStatus);
+   }
+   else if(rc == IME_SUCCESS)
+   {
+      lprintf(LOG_ERROR,"ME state error (%i), aborting", imeStatus.update_state);
+      rc = IME_ERROR;
+   }
+
+
+   if(
+      (rc == IME_SUCCESS) &&
+      (imeStatus.update_state == IME_STATE_UPDATE_IN_PROGRESS) 
+     )
+   {
+      uint8_t sequence = 0;
+      uint32_t counter = 0;
+      uint8_t retry = 0;
+      uint8_t shownPercent = 0xff;
+
+      while(   
+            (counter < imgCtx.size) && 
+            (rc == IME_SUCCESS) &&
+            (retry < IME_RETRY_COUNT)
+           )
+      {
+         uint8_t length = IME_UPGRADE_BUFFER_SIZE;
+         uint8_t currentPercent;
+
+         if( (imgCtx.size - counter) < IME_UPGRADE_BUFFER_SIZE )
+         {
+            length = (imgCtx.size - counter);
+         }
+
+         rc = ImeUpdateWriteArea(intf,sequence,length,&imgCtx.pData[counter]);
+         
+         /*
+         As per the flowchart Intel Dynamic Power Node Manager 1.5 IPMI Iface
+         page 65
+         We shall send the GetStatus command each time following a write area
+         but this add too much time to the upgrade
+         */   
+         /*  ImeUpdateGetStatus(intf,&imeStatus); */
+         counter += length;
+         sequence ++;
+
+
+         currentPercent = ((float)counter/imgCtx.size)*100;
+
+         if(currentPercent != shownPercent)
+         {
+            uint16_t timeElapsedSecond;
+            uint16_t timeRemainingSecond;
+            shownPercent = currentPercent;
+            printf("Percent: %02i,  ", shownPercent);
+            time(&current);
+            timeElapsedSecond = (current-start) + ((current-start)%60);
+            printf("Elapsed time %02ld:%02ld\r",((current-start)/60), ((current-start)%60));
+            fflush(stdout);
+
+         }
+      }
+      ImeUpdateGetStatus(intf,&imeStatus);
+      printf("\n");
+   }
+   else if(rc == IME_SUCCESS)
+   {
+      lprintf(LOG_ERROR,"ME state error (%i), aborting", imeStatus.update_state);
+      rc = IME_ERROR;
+   }
+
+   if(
+      (rc == IME_SUCCESS) &&
+      (imeStatus.update_state == IME_STATE_UPDATE_IN_PROGRESS) 
+     )
+   {
+      rc = ImeUpdateCloseArea(intf, imgCtx.size, imgCtx.crc8);
+      ImeUpdateGetStatus(intf,&imeStatus);
+   }
+   else if(rc == IME_SUCCESS)
+   {
+      lprintf(LOG_ERROR,"ME state error, aborting");
+      rc = IME_ERROR;
+   }
+
+   if(
+      (rc == IME_SUCCESS) &&
+      (imeStatus.update_state == IME_STATE_UPDATE_REQUESTED) 
+     )
+   {
+      printf("UpdateCompleted, Activate now\n");
+      rc = ImeUpdateRegisterUpdate(intf, IME_UPDTYPE_NORMAL);
+      ImeUpdateGetStatus(intf,&imeStatus);
+   }
+   else if(rc == IME_SUCCESS)
+   {
+      lprintf(LOG_ERROR,"ME state error, aborting");
+      rc = IME_ERROR;
+   }
+
+   if(
+      (rc == IME_SUCCESS) &&
+      (imeStatus.update_state == IME_STATE_SUCCESS) 
+     )
+   {
+      time(&end);
+      printf("Update Completed in %02ld:%02ld\n",(end-start)/60, (end-start)%60);
+   }
+   else
+   {
+      time(&end);
+      printf("Update Error\n");
+      printf("\nTime Taken %02ld:%02ld\n",(end-start)/60, (end-start)%60);
+   }
+
+   return rc;
+}
+
+
+static int ImeUpdatePrepare(struct ipmi_intf *intf)
+{
+   struct ipmi_rs * rsp;
+   struct ipmi_rq req;
+
+   #ifdef OUTPUT_DEBUG
+   printf("ImeUpdatePrepare\n");
+   #endif
+
+   memset(&req, 0, sizeof(req));
+   req.msg.netfn = 0x30;  // OEM NetFn
+   req.msg.cmd = 0xA0;
+   req.msg.data_len = 0;
+
+   rsp = intf->sendrecv(intf, &req);
+   if (rsp == NULL) {
+      lprintf(LOG_ERR, "UpdatePrepare command failed");
+      return IME_ERROR;
+   }
+   if (rsp->ccode > 0) {
+      lprintf(LOG_ERR, "UpdatePrepare command failed: %s",
+         val2str(rsp->ccode, completion_code_vals));
+      return IME_ERROR;
+   }
+
+   lprintf(LOG_DEBUG, "UpdatePrepare command succeed");
+   return IME_SUCCESS;
+}
+
+static int ImeUpdateOpenArea(struct ipmi_intf *intf)
+{
+   struct ipmi_rs * rsp;
+   struct ipmi_rq req;
+   uint8_t buffer[ 2 ];
+
+   #ifdef OUTPUT_DEBUG
+   printf("ImeUpdateOpenArea\n");
+   #endif
+
+   memset(&req, 0, sizeof(req));
+   req.msg.netfn = 0x30;  // OEM NetFn
+   req.msg.cmd = 0xA1;
+
+   buffer[0] = 0x01; // Area Type : Operational code
+   buffer[1] = 0x00; // Reserved : 0
+   req.msg.data = buffer;
+
+   req.msg.data_len = 2;
+
+   rsp = intf->sendrecv(intf, &req);
+   if (rsp == NULL) {
+      lprintf(LOG_ERR, "UpdateOpenArea command failed");
+      return IME_ERROR;
+   }
+   if (rsp->ccode > 0) {
+      lprintf(LOG_ERR, "UpdateOpenArea command failed: %s",
+         val2str(rsp->ccode, completion_code_vals));
+      return IME_ERROR;
+   }
+
+   lprintf(LOG_DEBUG, "UpdateOpenArea command succeed");
+   return IME_SUCCESS;
+}
+
+static int ImeUpdateWriteArea(
+                              struct ipmi_intf *intf,
+                              uint8_t sequence, 
+                              uint8_t length, 
+                              uint8_t * pBuf
+                          )
+{
+   struct ipmi_rs * rsp;
+   struct ipmi_rq req;
+   uint8_t buffer[ IME_UPGRADE_BUFFER_SIZE + 1 ];
+
+//   printf("ImeUpdateWriteArea %i\n", sequence);
+
+   if(length > IME_UPGRADE_BUFFER_SIZE)
+      return IME_ERROR;
+
+   buffer[0] = sequence;
+   memcpy(&buffer[1], pBuf, length);
+
+   memset(&req, 0, sizeof(req));
+   req.msg.netfn = 0x30;  // OEM NetFn
+   req.msg.cmd = 0xA2;
+   req.msg.data = buffer;
+   req.msg.data_len = length + 1;
+
+   rsp = intf->sendrecv(intf, &req);
+   if (rsp == NULL) {
+      lprintf(LOG_ERR, "UpdateWriteArea command failed");
+      return IME_ERROR;
+   }
+   if (rsp->ccode > 0) {
+      lprintf(LOG_ERR, "UpdateWriteArea command failed: %s",
+         val2str(rsp->ccode, completion_code_vals));
+      if( rsp->ccode == 0x80) // restart operation
+         return IME_RESTART;
+      else
+         return IME_ERROR;
+   }
+
+   lprintf(LOG_DEBUG, "UpdateWriteArea command succeed");
+   return IME_SUCCESS;
+}
+
+static int ImeUpdateCloseArea(
+                              struct ipmi_intf *intf,
+                              uint32_t size, 
+                              uint16_t checksum
+                          )
+{
+   struct ipmi_rs * rsp;
+   struct ipmi_rq req;
+   uint8_t length = sizeof( uint32_t ) + sizeof( uint16_t ); 
+   uint8_t buffer[ sizeof( uint32_t ) + sizeof( uint16_t ) ];
+
+   #ifdef OUTPUT_DEBUG
+   printf( "ImeUpdateCloseArea\n");
+   #endif
+
+   buffer[0] = (uint8_t)((size & 0x000000ff) >>  0);
+   buffer[1] = (uint8_t)((size & 0x0000ff00) >>  8);
+   buffer[2] = (uint8_t)((size & 0x00ff0000) >> 16);
+   buffer[3] = (uint8_t)((size & 0xff000000) >> 24);
+
+   buffer[4] = (uint8_t)((checksum & 0x00ff) >>  0);
+   buffer[5] = (uint8_t)((checksum & 0xff00) >>  8);
+
+   memset(&req, 0, sizeof(req));
+   req.msg.netfn = 0x30;  // OEM NetFn
+   req.msg.cmd = 0xA3;
+   req.msg.data = buffer;
+   req.msg.data_len = length;
+
+   rsp = intf->sendrecv(intf, &req);
+   if (rsp == NULL) {
+      lprintf(LOG_ERR, "UpdateCloseArea command failed");
+      return IME_ERROR;
+   }
+   if (rsp->ccode > 0) {
+      lprintf(LOG_ERR, "UpdateCloseArea command failed: %s",
+         val2str(rsp->ccode, completion_code_vals));
+      return IME_ERROR;
+   }
+
+   lprintf(LOG_DEBUG, "UpdateCloseArea command succeed");
+   return IME_SUCCESS;
+}
+
+static int ImeUpdateGetStatus(struct ipmi_intf *intf, tImeStatus *pStatus )
+{
+   struct      ipmi_rs * rsp;
+   struct      ipmi_rq req;
+   tImeStatus *pGetStatus;
+   
+   memset(pStatus, 0, sizeof(tImeStatus));
+   pStatus->update_state = IME_STATE_ABORTED;
+
+
+   #ifdef OUTPUT_DEBUG
+   printf("ImeUpdateGetStatus: ");
+   #endif
+
+   memset(&req, 0, sizeof(req));
+   req.msg.netfn = 0x30;  // OEM NetFn
+   req.msg.cmd = 0xA6;
+   req.msg.data_len = 0;
+
+   rsp = intf->sendrecv(intf, &req);
+   if (rsp == NULL) {
+      lprintf(LOG_ERR, "UpdatePrepare command failed");
+      return IME_ERROR;
+   }
+   if (rsp->ccode > 0) {
+      lprintf(LOG_ERR, "UpdatePrepare command failed: %s",
+         val2str(rsp->ccode, completion_code_vals));
+      return IME_ERROR;
+   }
+
+   lprintf(LOG_DEBUG, "UpdatePrepare command succeed");
+
+   pGetStatus = (tImeStatus *) rsp->data;
+   
+   memcpy( pStatus, pGetStatus, sizeof(tImeStatus));
+
+   #ifdef OUTPUT_DEBUG
+   printf("%x - ", pStatus->updateState);
+
+   switch( pStatus->update_state )
+   {
+      case IME_STATE_IDLE:
+         printf("IDLE\n");
+      break;
+      case IME_STATE_UPDATE_REQUESTED:
+         printf("Update Requested\n");
+      break;
+      case IME_STATE_UPDATE_IN_PROGRESS:
+         printf("Update in Progress\n");
+      break;
+      case IME_STATE_SUCCESS:
+         printf("Update Success\n");
+      break;
+      case IME_STATE_FAILED:
+         printf("Update Failed\n");
+      break;
+      case IME_STATE_ROLLED_BACK:
+         printf("Update Rolled Back\n");
+      break;
+      case IME_STATE_ABORTED:
+         printf("Update Aborted\n");
+      break;
+      case IME_STATE_INIT_FAILED:
+         printf("Update Init Failed\n");
+      break;
+      default:
+         printf("Unknown, reserved\n");
+      break;
+   }
+   #endif
+
+   return IME_SUCCESS;
+}
+
+static int ImeUpdateGetCapabilities(struct ipmi_intf *intf, tImeCaps *pCaps )
+{
+   struct      ipmi_rs * rsp;
+   struct      ipmi_rq req;
+   tImeCaps *  pGetCaps;
+   
+   memset(pCaps, 0, sizeof(tImeCaps));
+
+
+   #ifdef OUTPUT_DEBUG
+   printf("ImeUpdateGetStatus: ");
+   #endif
+
+   memset(&req, 0, sizeof(req));
+   req.msg.netfn = 0x30;  // OEM NetFn
+   req.msg.cmd = 0xA7;
+   req.msg.data_len = 0;
+
+   rsp = intf->sendrecv(intf, &req);
+   if (rsp == NULL) {
+      lprintf(LOG_ERR, "UpdatePrepare command failed");
+      return IME_ERROR;
+   }
+   if (rsp->ccode > 0) {
+      lprintf(LOG_ERR, "UpdatePrepare command failed: %s",
+         val2str(rsp->ccode, completion_code_vals));
+      return IME_ERROR;
+   }
+
+   lprintf(LOG_DEBUG, "UpdatePrepare command succeed");
+
+   pGetCaps = (tImeCaps *) rsp->data;
+   
+   memcpy( pCaps, pGetCaps, sizeof(tImeCaps));
+
+   return IME_SUCCESS;
+}
+
+
+static int ImeUpdateRegisterUpdate(struct ipmi_intf *intf, tImeUpdateType type)
+{
+   struct ipmi_rs * rsp;
+   struct ipmi_rq req;
+   uint8_t buffer[ 2 ];
+
+   #ifdef OUTPUT_DEBUG
+   printf( "ImeUpdateRegisterUpdate\n");
+   #endif
+
+   buffer[0] = type;  // Normal Update
+   buffer[1] = 0;  // Flags, reserved
+
+   memset(&req, 0, sizeof(req));
+   req.msg.netfn = 0x30;  // OEM NetFn
+   req.msg.cmd = 0xA4;
+   req.msg.data = buffer;
+   req.msg.data_len = 2;
+
+   rsp = intf->sendrecv(intf, &req);
+   if (rsp == NULL) {
+      lprintf(LOG_ERR, "ImeUpdateRegisterUpdate command failed");
+      return IME_ERROR;
+   }
+   if (rsp->ccode > 0) {
+      lprintf(LOG_ERR, "ImeUpdateRegisterUpdate command failed: %s",
+         val2str(rsp->ccode, completion_code_vals));
+      return IME_ERROR;
+   }
+
+   lprintf(LOG_DEBUG, "ImeUpdateRegisterUpdate command succeed");
+   return IME_SUCCESS;
+}
+
+
+
+
+static int ImeUpdateShowStatus(struct ipmi_intf *intf)
+{
+   struct ipmi_rs * rsp;
+   struct ipmi_rq req;
+   tImeStatus *pStatus;
+
+   printf("ImeUpdateGetStatus: ");
+
+   memset(&req, 0, sizeof(req));
+   req.msg.netfn = 0x30;  // OEM NetFn
+   req.msg.cmd = 0xA6;
+   req.msg.data_len = 0;
+
+   rsp = intf->sendrecv(intf, &req);
+   if (rsp == NULL) {
+      lprintf(LOG_ERR, "UpdatePrepare command failed");
+      return IME_ERROR;
+   }
+   if (rsp->ccode > 0) {
+      lprintf(LOG_ERR, "UpdatePrepare command failed: %s",
+         val2str(rsp->ccode, completion_code_vals));
+      return IME_ERROR;
+   }
+
+   lprintf(LOG_DEBUG, "UpdatePrepare command succeed");
+
+   pStatus = (tImeStatus *) rsp->data ;
+
+   
+   printf("image_status: %x - ", pStatus->image_status);
+
+   printf("update_state: %x - ", pStatus->update_state);
+
+   switch( pStatus->update_state )
+   {
+      case IME_STATE_IDLE:
+         printf("IDLE\n");
+      break;
+      case IME_STATE_UPDATE_REQUESTED:
+         printf("Update Requested\n");
+      break;
+      case IME_STATE_UPDATE_IN_PROGRESS:
+         printf("Update in Progress\n");
+      break;
+      case IME_STATE_SUCCESS:
+         printf("Update Success\n");
+      break;
+      case IME_STATE_FAILED:
+         printf("Update Failed\n");
+      break;
+      case IME_STATE_ROLLED_BACK:
+         printf("Update Rolled Back\n");
+      break;
+      case IME_STATE_ABORTED:
+         printf("Update Aborted\n");
+      break;
+      case IME_STATE_INIT_FAILED:
+         printf("Update Init Failed\n");
+      break;
+      default:
+         printf("Unknown, reserved\n");
+      break;
+   }
+   printf("update_attempt_status  : %x\n", pStatus->update_attempt_status);
+   printf("rollback_attempt_status: %x\n", pStatus->rollback_attempt_status);
+   printf("update_type            : %x\n", pStatus->update_type);
+   printf("dependent_flag         : %x\n", pStatus->dependent_flag);
+   printf("free_area_size         : %x\n", pStatus->free_area_size[0]);
+   printf("                       : %x\n", pStatus->free_area_size[1]);
+   printf("                       : %x\n", pStatus->free_area_size[2]);
+   printf("                       : %x\n", pStatus->free_area_size[3]);
+
+   return IME_SUCCESS;
+}
+
+
+static int ImeImageCtxFromFile(
+                                 char* imageFilename, 
+                                 tImeUpdateImageCtx * pImageCtx
+                               )
+{
+   int rc = IME_SUCCESS;
+   FILE* pImageFile = fopen(imageFilename, "rb");
+   
+   if ( pImageFile == NULL )
+   {
+      lprintf(LOG_NOTICE,"Cannot open image file %s", imageFilename);
+      rc = IME_ERROR;
+   }
+   
+   if ( rc == IME_SUCCESS )
+   {
+      /* Get the raw data in file */
+      fseek(pImageFile, 0, SEEK_END);
+      pImageCtx->size  = ftell(pImageFile); 
+      if (pImageCtx->size <= 0) {
+         if (pImageCtx->size < 0)
+            lprintf(LOG_ERR, "Error seeking %s. %s\n", imageFilename, strerror(errno));
+         rc = IME_ERROR;
+         fclose(pImageFile);
+         return rc;
+      }
+      pImageCtx->pData = malloc(sizeof(unsigned char)*pImageCtx->size);
+      rewind(pImageFile);
+
+      if ( pImageCtx->pData != NULL )
+      {
+         if (pImageCtx->size < fread(pImageCtx->pData, sizeof(unsigned char), 
+                                                   pImageCtx->size, pImageFile))
+            rc = IME_ERROR;
+      }
+      else
+      {
+         rc = IME_ERROR;
+      }
+   }
+   
+   // Calculate checksum CRC8  
+   if ( rc == IME_SUCCESS )
+   {
+      pImageCtx->crc8 = ImeCrc8(pImageCtx->size, pImageCtx->pData);
+   }
+
+    
+   if( pImageFile != NULL)
+   {
+      fclose(pImageFile);
+   }
+    
+   return rc;
+}  
+
+static uint8_t ImeCrc8( uint32_t length, uint8_t * pBuf )
+{
+   uint8_t crc = 0;
+   uint32_t bufCount;
+
+   for ( bufCount = 0; bufCount < length; bufCount++ )
+   {
+      uint8_t count;
+
+      crc = crc ^ pBuf[bufCount];
+  
+      for ( count = 0; count < 8; count++ ) 
+      {
+         if (( crc & 0x80 ) != 0 )
+         {
+            crc <<= 1;
+            crc ^= 0x07;
+         }
+         else
+         {
+            crc <<= 1;
+         }
+      }
+   }
+
+   lprintf(LOG_DEBUG,"CRC8: %02xh\n", crc);
+   return crc;
+} 
+
+
+static int ImeManualRollback(struct ipmi_intf *intf)
+{
+   int rc = IME_SUCCESS;
+   tImeStatus imeStatus;
+   time_t start,end,current;
+   
+
+   rc = ImeUpdateRegisterUpdate(intf, IME_UPDTYPE_MANUAL_ROLLBACK);
+   ImeUpdateGetStatus(intf,&imeStatus);
+
+
+   if(
+      (rc == IME_SUCCESS) &&
+      (imeStatus.update_state == IME_STATE_ROLLED_BACK) 
+     )
+   {
+      printf("Manual Rollback Succeed\n");
+      return IME_SUCCESS;
+   }
+   else
+   {
+      printf("Manual Rollback Completed With Error\n");
+      return IME_ERROR;
+   }
+}
+
+
+
+static void ImePrintUsage(void)
+{
+   lprintf(LOG_NOTICE,"help                    - This help menu");   
+   lprintf(LOG_NOTICE,"info                    - Information about the present Intel ME");   
+   lprintf(LOG_NOTICE,"update <file>           - Upgrade the ME firmware from received image <file>");
+   lprintf(LOG_NOTICE,"rollback                - Manual Rollback ME");
+//   lprintf(LOG_NOTICE,"rollback                - Rollback ME Firmware");
+}
+
+
+
+int ipmi_ime_main(struct ipmi_intf * intf, int argc, char ** argv)
+{
+   int rc = IME_SUCCESS;
+   
+   lprintf(LOG_DEBUG,"ipmi_ime_main()");
+   
+
+   if ( (argc == 0) || (strcmp(argv[0], "help") == 0) ) 
+   {
+      ImePrintUsage();
+   }
+   else if ( (argc == 0) || (strcmp(argv[0], "info") == 0) ) 
+   {
+      rc = ImeGetInfo(intf);
+   }
+   else if ( strcmp(argv[0], "update") == 0) 
+   {
+      if(argc == 2)
+      {
+         lprintf(LOG_NOTICE,"Update using file: %s", argv[1]);
+         rc = ImeUpgrade(intf, argv[1]);
+      }
+      else
+      {
+         lprintf(LOG_ERROR,"File must be provided with this option, see help\n");
+         rc = IME_ERROR;
+      }
+   }
+   else if ( (argc == 0) || (strcmp(argv[0], "rollback") == 0) ) 
+   {
+      rc = ImeManualRollback(intf);
+   }
+   else
+   {
+      ImePrintUsage(); 
+   }
+   
+   return rc;
+}
+
+
+