Imported Upstream version 2.9.3upstream/2.9.3

1 files changed, 6095 insertions, 0 deletions

diff --git a/util/oem_dell.c b/util/oem_dell.c
new file mode 100644
index 0000000..1911d96
--- /dev/null
+++ b/util/oem_dell.c
@@ -0,0 +1,6095 @@
+/*
+ * oem_dell.c
+ * Handle Dell OEM command functions
+ *
+ * Change history:
+ *  08/17/2011 ARCress - included in ipmiutil source tree
+ *
+ */
+/******************************************************************
+Copyright (c) 2008, Dell 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:
+- Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+
+- Redistributions 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 Dell Inc nor the names of its contributors
+may be used to endorse or promote products derived from this software 
+without specific prior written permission. 
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE. 
+
+
+******************************************************************/
+/*
+* Thursday Oct 7 17:30:12 2009
+* <deepaganesh_paulraj@dell.com>
+*
+* This code implements a dell OEM proprietary commands.
+* This Code is edited and Implemented the License feature for Delloem
+* Author Harsha S <Harsha_S1@dell.com>
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#ifdef WIN32
+#include <windows.h>
+#define int8_t   char
+#define uint8_t  unsigned char
+#define uint16_t unsigned short
+#define uint32_t unsigned int
+#define uint64_t unsigned long
+#include "getopt.h"
+#else
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <errno.h>
+#include <unistd.h>
+#include <signal.h>
+#include <ctype.h>
+#include <limits.h>
+#if defined(HPUX)
+/* getopt is defined in stdio.h */
+#elif defined(MACOS)
+/* getopt is defined in unistd.h */
+#include <unistd.h>
+#include <stdint.h>
+#else
+#include <getopt.h>
+#endif
+#endif
+
+#include <time.h>
+#include "ipmicmd.h"
+#include "isensor.h"
+#include "ievents.h"
+#include "oem_dell.h"
+
+// #ifdef METACOMMAND is assumed 
+extern int i_sol(int  argc, char **argv);  /*isol.c*/
+extern void lprintf(int level, const char * format, ...); /*ipmilanplus.c*/
+extern void set_loglevel(int level);
+extern void printbuf(const uint8_t * buf, int len, const char * desc);
+
+#define IPMI_DELL_OEM_NETFN        (uint8_t)(0x30)
+#define GET_CHASSIS_LED_STATE      (uint8_t)(0x32)
+#define GET_IDRAC_VIRTUAL_MAC      (uint8_t)(0xC9)
+// 11g Support Macros
+#define INVALID 		 	-1
+#define SHARED 			  	0
+#define SHARED_WITH_FAILOVER_LOM2 	1
+#define DEDICATED 		 	2
+#define SHARED_WITH_FAILOVER_ALL_LOMS 	3
+char ActiveLOM_String[6][10] = {"None","LOM1","LOM2","LOM3","LOM4","dedicated"};
+#define INVAILD_FAILOVER_MODE   	-2
+#define INVAILD_FAILOVER_MODE_SETTINGS  -3
+#define INVAILD_SHARED_MODE             -4
+
+#define        INVAILD_FAILOVER_MODE_STRING    "ERROR: Cannot set shared with failover lom same as current shared lom.\n"
+#define        INVAILD_FAILOVER_MODE_SET       "ERROR: Cannot set shared with failover loms when NIC is set to dedicated Mode.\n"
+#define        INVAILD_SHARED_MODE_SET_STRING  "ERROR: Cannot set shared Mode for Blades.\n"
+
+// 11g Support Strings for nic selection
+char NIC_Selection_Mode_String [4] [50] =	{	"shared",  
+						"shared with failover lom2",
+						"dedicated",
+						"shared with Failover all loms"
+						};
+
+// 11g Support Macros (dups)
+//#define SHARED 0
+//#define SHARED_WITH_FAILOVER_LOM2 1
+//#define DEDICATED 2
+//#define SHARED_WITH_FAILOVER_ALL_LOMS 3
+
+// 12g Support Strings for nic selection
+char NIC_Selection_Mode_String_12g[] [50] =	{	
+						"dedicated",
+						"shared with lom1",  
+						"shared with lom2",
+						"shared with lom3",
+						"shared with lom4",
+						"shared with failover lom1",
+						"shared with failover lom2",
+						"shared with failover lom3",
+						"shared with failover lom4",
+						"shared with failover all loms"
+						};
+
+static char * progver   = "2.93";
+static char * progname  = "idelloem";
+static int verbose = 0;
+static char fdebug = 0;
+static uchar  g_bus  = PUBLIC_BUS;
+static uchar  g_sa   = BMC_SA;
+static uchar  g_lun  = BMC_LUN;
+static uchar  g_addrtype = ADDR_SMI;
+static uchar *sdrcache = NULL;
+static char  *sdrfile = NULL;
+static int    argc_sav; 
+static char **argv_sav;
+static int current_arg =0;
+uint8_t iDRAC_FLAG=0;
+LCD_MODE lcd_mode;
+static uint8_t LcdSupported=0;
+static uint8_t SetLEDSupported=0;
+
+volatile uint8_t IMC_Type = IMC_IDRAC_10G;
+
+
+const struct vFlashstr vFlash_completion_code_vals[] = {
+	{0x00, "SUCCESS"},
+	{0x01, "NO_SD_CARD"},
+	{0x63, "UNKNOWN_ERROR"},
+	{0x00, NULL}
+};
+
+
+POWER_HEADROOM powerheadroom;
+
+uint8_t PowercapSetable_flag=0;
+uint8_t PowercapstatusFlag=0;
+
+static void usage(void);
+
+/* LCD Function prototypes */
+static int ipmi_delloem_lcd_main (void * intf, int  argc, char ** argv);
+static int ipmi_lcd_get_platform_model_name (void * intf,char* lcdstring,
+                        uint8_t max_length,uint8_t field_type);
+static int ipmi_idracvalidator_command (void * intf);
+static int ipmi_lcd_get_configure_command_wh (void * intf);
+static int ipmi_lcd_get_configure_command (void * intf,uint8_t *command);
+static int ipmi_lcd_set_configure_command (void * intf, int command);
+static int ipmi_lcd_set_configure_command_wh (void * intf, uint32_t  mode,
+                        uint16_t lcdqualifier,uint8_t errordisp);
+static int ipmi_lcd_get_single_line_text (void * intf, char* lcdstring, uint8_t max_length);
+static int ipmi_lcd_get_info_wh(void * intf);
+static int ipmi_lcd_get_info(void * intf);
+static int ipmi_lcd_get_status_val(void * intf, LCD_STATUS* lcdstatus);
+static int IsLCDSupported ();
+static void CheckLCDSupport(void * intf);
+static void ipmi_lcd_status_print( LCD_STATUS lcdstatus);
+static int ipmi_lcd_get_status(void * intf );
+static int ipmi_lcd_set_kvm(void * intf, char status);
+static int ipmi_lcd_set_lock(void * intf,  char lock);
+static int ipmi_lcd_set_single_line_text (void * intf, char * text);
+static int ipmi_lcd_set_text(void * intf, char * text, int line_number);
+static int ipmi_lcd_configure_wh (void * intf, uint32_t  mode ,
+                       uint16_t lcdqualifier, uint8_t errordisp, 
+                       int8_t line_number, char * text);
+static int ipmi_lcd_configure (void * intf, int command, 
+                    int8_t line_number, char * text);
+static void ipmi_lcd_usage(void);
+
+/* MAC Function prototypes */
+static int ipmi_delloem_mac_main (void * intf, int  argc, char ** argv);
+static int make_int(const char *str, int *value);
+static void InitEmbeddedNICMacAddressValues ();
+static int ipmi_macinfo_drac_idrac_virtual_mac(void* intf,uint8_t NicNum);
+static int ipmi_macinfo_drac_idrac_mac(void* intf,uint8_t NicNum);
+static int ipmi_macinfo_10g (void* intf, uint8_t NicNum);
+static int ipmi_macinfo_11g (void* intf, uint8_t NicNum);
+static int ipmi_macinfo (void* intf, uint8_t NicNum);
+static void ipmi_mac_usage(void);
+
+/* LAN Function prototypes */
+static int ipmi_delloem_lan_main (void * intf, int  argc, char ** argv);
+static int IsLANSupported ();
+static int get_nic_selection_mode (int current_arg, char ** argv);
+static int ipmi_lan_set_nic_selection (void* intf, uint8_t nic_selection);
+static int ipmi_lan_get_nic_selection (void* intf);
+static int get_nic_selection_mode_12g (void* intf,int iarg, char **argv, char *nic_set);
+static int ipmi_lan_get_active_nic (void* intf);
+static void ipmi_lan_usage(void);
+static int ipmi_lan_set_nic_selection_12g (void* intf, uint8_t* nic_selection);
+
+/* POwer monitor Function prototypes */
+static int ipmi_delloem_powermonitor_main (void * intf, int  argc, char **argv);
+static void ipmi_time_to_str(time_t rawTime, char* strTime);
+static int ipmi_get_power_capstatus_command (void * intf);
+static int ipmi_set_power_capstatus_command (void * intf,uint8_t val);
+static int ipmi_powermgmt(void* intf);
+static int ipmi_powermgmt_clear(void* intf,uint8_t clearValue);
+static uint64_t watt_to_btuphr_conversion(uint32_t powerinwatt);
+static uint32_t btuphr_to_watt_conversion(uint64_t powerinbtuphr);
+static int ipmi_get_power_headroom_command (void * intf,uint8_t unit);
+static int ipmi_get_power_consumption_data(void* intf,uint8_t unit);
+static int ipmi_get_instan_power_consmpt_data(void* intf,
+                        IPMI_INST_POWER_CONSUMPTION_DATA* instpowerconsumptiondata);
+static void ipmi_print_get_instan_power_Amps_data(IPMI_INST_POWER_CONSUMPTION_DATA instpowerconsumptiondata);
+static int ipmi_print_get_power_consmpt_data(void* intf,uint8_t  unit);
+static int ipmi_get_avgpower_consmpt_history(void* intf,IPMI_AVGPOWER_CONSUMP_HISTORY* pavgpower );
+static int ipmi_get_peakpower_consmpt_history(void* intf,IPMI_POWER_CONSUMP_HISTORY * pstPeakpower);
+static int ipmi_get_minpower_consmpt_history(void* intf,IPMI_POWER_CONSUMP_HISTORY * pstMinpower);
+static int ipmi_print_power_consmpt_history(void* intf,int unit );
+static int ipmi_get_power_cap(void* intf,IPMI_POWER_CAP* ipmipowercap );
+static int ipmi_print_power_cap(void* intf,uint8_t unit );
+static int ipmi_set_power_cap(void* intf,int unit,int val );
+static void ipmi_powermonitor_usage(void);
+
+/* vFlash Function prototypes */
+static int ipmi_delloem_vFlash_main(void * intf, int  argc, char ** argv);
+const char * get_vFlash_compcode_str(uint8_t vflashcompcode, const struct vFlashstr *vs);
+static int ipmi_get_sd_card_info(void* intf);
+static int ipmi_delloem_vFlash_process(void* intf, int current_arg, char ** argv);
+static void ipmi_vFlash_usage(void);
+
+
+/* windbg Function prototypes */
+volatile uint8_t windbgsession = 0;
+static int ipmi_delloem_windbg_main (void * intf, int  argc, char ** argv);
+static int ipmi_windbg_start (void * intf);
+static int ipmi_windbg_end (void * intf);
+static void ipmi_windbg_usage (void);
+
+
+
+/* LED Function prototypes */
+
+static int ipmi_getsesmask(int, char **);
+static int CheckSetLEDSupport(void * intf);
+static int IsSetLEDSupported(void);
+static void ipmi_setled_usage(void);
+static int ipmi_delloem_setled_main(void *intf, int  argc, char ** argv);
+static int ipmi_delloem_getled_main(void *intf, int  argc, char ** argv);
+static int ipmi_setled_state (void * intf, int bayId, int slotId, int state);
+static int ipmi_getdrivemap (void * intf, int b, int d, int f, int *bayId, int *slotId);
+//extern int optind;  /*from getopt*/
+
+static int ipmi_sol_activate(void *intf, int j, int k) 
+{ 
+   char **args;
+   int rv, i, n;
+   int x = 0;
+   n = argc_sav;
+   args = argv_sav;
+   /* use the user-specified args, but switch to sol */
+   for (i = 0; i < n; i++) {
+      if (strcmp(args[i],"ipmiutil") == 0) { x = 1; } 
+      else if (strcmp(args[i],"delloem") == 0) args[i] = "sol";
+      else if (strcmp(args[i],"windbg") == 0) args[i] = "-a";
+      else if (strcmp(args[i],"start") == 0) args[i] = "-a";
+   }
+   ipmi_close_();
+   if (x == 1) { args++; n--; }
+   optind = 0;
+   rv = i_sol(n, args);
+   return rv; 
+}
+
+static int ipmi_sol_deactivate(void *intf) 
+{
+   char **args;
+   int rv, i, n;
+   int x = 0;
+   n = argc_sav;
+   args = argv_sav;
+   /* use the user-specified args, but switch to sol */
+   for (i = 0; i < n; i++) {
+      if (strcmp(args[i],"ipmiutil") == 0) { x = 1; } 
+      else if (strcmp(args[i],"delloem") == 0) args[i] = "sol";
+      else if (strcmp(args[i],"windbg") == 0) args[i] = "-d";
+      else if (strcmp(args[i],"end") == 0) args[i] = "-d";
+   }
+   ipmi_close_();
+   if (x == 1) { args++; n--; }
+   optind = 0;
+   rv = i_sol(n, args);
+   return rv;
+}
+
+static int sysinfo_param(const char *str) {
+    // SysInfo Parameters
+    //   1  = system firmware version
+    //   2  = system hostname
+    //   3  = primary operating system name (non-volatile)
+    //   4  = operating system name (volatile)
+    // 0xe3 = dell: os version
+    // 0xde = dell: url
+    if (!strcmp(str, "system_name")) return 0x02;
+    if (!strcmp(str, "primary_os_name")) return 0x03;
+    if (!strcmp(str, "os_name")) return 0x04;
+    if (!strcmp(str, "dell_os_version")) return 0xe4;
+    if (!strcmp(str, "dell_url")) return 0xde;
+    return strtoul(str, 0, 16);
+}
+
+static void ipmi_sysinfo_usage()
+{
+       lprintf(LOG_NOTICE, "");
+       lprintf(LOG_NOTICE, "   getsysinfo (os_name|primary_os_name|dell_os_version|dell_url)");
+       lprintf(LOG_NOTICE, "      Retrieves system info from bmc for given argument");
+       lprintf(LOG_NOTICE, "   setsysinfo (os_name|primary_os_name|dell_os_version|dell_url)");
+       lprintf(LOG_NOTICE, "      Stores system Info for given argument to bmc");
+       lprintf(LOG_NOTICE, "");
+       lprintf(LOG_NOTICE, "   primary_os_name = primary operating system name");
+       lprintf(LOG_NOTICE, "   os_name = secondary operating system name");
+       lprintf(LOG_NOTICE, "   system_name = system hostname of server");
+       lprintf(LOG_NOTICE, "   dell_os_version = running version of operating system (Dell)");
+       lprintf(LOG_NOTICE, "   dell_url = url of bmc webserver (Dell)");
+
+       lprintf(LOG_NOTICE, "");
+}
+
+static int
+ipmi_delloem_sysinfo_main(void * intf, int  argc, char ** argv)
+{
+    int param, isset;
+    char *str;
+    unsigned char  infostr[256], *pos;
+    int   j, ret;
+
+    /* Is this a setsysinfo or getsysinfo */
+    isset = !strncmp(argv[current_arg], "setsysinfo\0",10);
+
+    current_arg++;
+    if (argc < current_arg) {
+       usage();
+       return -1;
+    }
+    if (argc == 1 || strcmp(argv[current_arg], "help") == 0 ||
+       argc < (isset ? current_arg+2 : current_arg+1)) {
+       ipmi_sysinfo_usage();
+       return 0;
+    }
+    memset(infostr, 0, sizeof(infostr));
+
+    param = sysinfo_param(argv[current_arg++]);
+
+    if (isset) {
+	str = argv[current_arg];
+	j = strlen_(str);
+	ret = set_system_info(param,str,j);
+    } else {
+	pos = infostr;
+	j = sizeof(infostr);
+        ret = get_system_info(param,infostr,&j);
+	printf("%s\n", infostr);
+    }
+    return ret;
+}
+
+static void ipmi_password_policy_usage(void)
+{
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "   passwordpolicy <on | off>");
+    lprintf(LOG_NOTICE, "      Set the OEM Password Policy Check on or off");
+    lprintf(LOG_NOTICE, "      This parameter is write-only");
+    lprintf(LOG_NOTICE, "");
+}
+
+static int
+ipmi_delloem_password_policy(void * intf, int  argc, char ** argv)
+{
+    int rv = 0;
+    int rsp_len;
+    struct ipmi_rq req = {0};
+    uint8_t data[4];
+    uint8_t rsp[IPMI_RSPBUF_SIZE];
+    uint8_t bval;
+    
+
+    current_arg++;
+    if (argc < current_arg) {
+        usage();
+        return -1;
+    }
+
+    if (strcmp(argv[current_arg], "on") == 0) {
+	bval = 0x01;
+    } else if (strcmp(argv[current_arg], "off") == 0) {
+	bval = 0x00;
+    } else {   /* other or "help" */
+        ipmi_password_policy_usage();
+	return 0;
+    }
+
+    printf("Setting OEM Password Policy Check to %s ...\n", argv[current_arg]);
+        req.msg.netfn = 0x30;  /*Dell OEM netfn*/
+        req.msg.lun = 0;
+        req.msg.cmd = 0x51;
+        req.msg.data_len = 1;
+        req.msg.data = data;
+        data[0] = bval; 
+	rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+	if (rv) {
+	   printf("Error setting OEM password policy: ");
+	   if (rv < 0) printf("no response\n");
+	   else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+	}
+    if (rv == 0) printf("successful\n");
+    /* This works for DELL C6220 with firmware >= 1.23 */
+
+    return(rv);
+}
+
+/*****************************************************************
+* Function Name:       ipmi_delloem_main
+*
+* Description:         This function processes the delloem command
+* Input:               intf    - ipmi interface
+                       argc    - no of arguments
+                       argv    - argument string array
+* Output:        
+*
+* Return:              return code     0 - success
+*                                      -1 - failure
+*
+******************************************************************/
+
+int
+ipmi_delloem_main(void * intf, int  argc, char ** argv)
+{
+    int rc = 0;
+
+    // ipmi_idracvalidator_command(intf);
+    // CheckLCDSupport (intf);
+    // CheckSetLEDSupport (intf);
+
+    if (argc == 0 || strncmp(argv[0], "help\0", 5) == 0) 
+    {
+        usage();
+        return 0;
+    }
+
+    if (0 ==strncmp(argv[current_arg], "lcd\0", 4) ) 
+    {
+        rc = ipmi_delloem_lcd_main (intf,argc,argv);
+    }
+    /* mac address*/
+    else if (strncmp(argv[current_arg], "mac\0", 4) == 0) 
+    {
+        rc = ipmi_delloem_mac_main (intf,argc,argv);
+    }
+    /* lan address*/
+    else if (strncmp(argv[current_arg], "lan\0", 4) == 0) 
+    {
+        rc = ipmi_delloem_lan_main (intf,argc,argv);
+    }
+    /* SetLED support */
+    else if (strncmp(argv[current_arg], "setled\0", 7) == 0)
+    {
+        rc = ipmi_delloem_setled_main (intf,argc,argv);
+    }
+    else if (strncmp(argv[current_arg], "getled\0", 13) == 0) 
+    {
+        rc = ipmi_delloem_getled_main (intf,argc,argv);
+    }
+    else if (strncmp(argv[current_arg], "passwordpolicy\0", 14) == 0) 
+    {
+        rc = ipmi_delloem_password_policy (intf,argc,argv);
+    }
+    /*Powermanagement report processing*/
+    else if (strncmp(argv[current_arg], "powermonitor\0", 13) == 0) 
+    {
+        rc = ipmi_delloem_powermonitor_main (intf,argc,argv);
+    }
+	/* vFlash Support */	
+	else if (strncmp(argv[current_arg], "vFlash\0", 7) == 0)
+	{
+        rc = ipmi_delloem_vFlash_main (intf,argc,argv);	
+	}
+	else if (strncmp(argv[current_arg], "windbg\0", 7) == 0) 
+	{
+        rc = ipmi_delloem_windbg_main (intf,argc,argv);		
+	}
+	else if ((strncmp(argv[current_arg], "getsysinfo\0", 10) == 0) ||
+	         (strncmp(argv[current_arg], "setsysinfo\0", 10) == 0))
+	{
+        rc = ipmi_delloem_sysinfo_main (intf,argc,argv);		
+	}
+    else
+    {
+        usage();
+        return ERR_USAGE;
+    }
+    return rc;
+}
+
+/*****************************************************************
+* Function Name:     usage
+*
+* Description:       This function prints help message for delloem command
+* Input:           
+* Output:       
+*
+* Return:              
+*
+******************************************************************/
+
+static void usage(void)
+{
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "usage: delloem <command> [option...]");
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "commands:");
+    lprintf(LOG_NOTICE, "    lcd"); 
+    lprintf(LOG_NOTICE, "    mac");         
+    lprintf(LOG_NOTICE, "    lan");
+    lprintf(LOG_NOTICE, "    setled");         
+    lprintf(LOG_NOTICE, "    getled");         
+    lprintf(LOG_NOTICE, "    powermonitor");        
+    lprintf(LOG_NOTICE, "    windbg");	
+    lprintf(LOG_NOTICE, "    vFlash");
+    lprintf(LOG_NOTICE, "    getsysinfo");
+    lprintf(LOG_NOTICE, "    setsysinfo");
+    lprintf(LOG_NOTICE, "    passwordpolicy");
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "For help on individual commands type:");
+    lprintf(LOG_NOTICE, "delloem <command> help");
+
+}
+
+/*****************************************************************
+* Function Name:       ipmi_delloem_lcd_main
+*
+* Description:         This function processes the delloem lcd command
+* Input:               intf    - ipmi interface
+                       argc    - no of arguments
+                       argv    - argument string array
+* Output:        
+*
+* Return:              return code     0 - success
+*                         -1 - failure
+*
+******************************************************************/
+
+static int ipmi_delloem_lcd_main (void * intf, int  argc, char ** argv)
+{
+    int rc = 0;
+
+    current_arg++;
+    if (argc < current_arg) 
+    {
+        usage();
+        return -1;
+    }
+
+
+    /* ipmitool delloem lcd info*/
+    if (argc == 1 || strcmp(argv[current_arg], "help") == 0)
+    {
+        ipmi_lcd_usage();
+	return 0;
+    }
+    CheckLCDSupport (intf);
+    ipmi_idracvalidator_command(intf);
+    if (!IsLCDSupported()) {
+        printf("lcd is not supported on this system.\n");
+        return -1;
+    }
+    else if (strncmp(argv[current_arg], "info\0", 5) == 0) 
+    {
+	if((iDRAC_FLAG==IDRAC_11G) || (iDRAC_FLAG==IDRAC_12G) )            
+            rc = ipmi_lcd_get_info_wh(intf);
+        else
+            rc = ipmi_lcd_get_info(intf);
+    }
+    else if (strncmp(argv[current_arg], "status\0", 7) == 0)
+    {
+        rc = ipmi_lcd_get_status(intf);
+    }
+    /* ipmitool delloem lcd set*/
+    else if (strncmp(argv[current_arg], "set\0", 4) == 0) 
+    {
+        uint8_t line_number = 0;
+        current_arg++;
+        if (argc <= current_arg) 
+        {
+            ipmi_lcd_usage();
+            return -1;
+        }
+        if (strncmp(argv[current_arg], "line\0", 5) == 0) 
+        {
+            current_arg++;
+            if (argc <= current_arg) {usage();return -1;}
+            line_number = (uint8_t)strtoul(argv[current_arg], NULL, 0);
+            current_arg++;
+            if (argc <= current_arg) {usage();return -1;}
+        }
+
+
+		if ((strncmp(argv[current_arg], "mode\0", 5) == 0)&&((iDRAC_FLAG==IDRAC_11G) || (iDRAC_FLAG==IDRAC_12G) )) 
+        {
+            current_arg++;
+            if (argc <= current_arg) 
+            {
+                ipmi_lcd_usage();
+                return -1;
+            }    
+            if (argv[current_arg] == NULL)  
+            {
+                ipmi_lcd_usage();
+                return -1;
+            }
+            if (strncmp(argv[current_arg], "none\0", 5) == 0) 
+            {
+                rc = ipmi_lcd_configure_wh (intf, IPMI_DELL_LCD_CONFIG_NONE,0xFF,0XFF, 0, NULL);
+            }
+            else if (strncmp(argv[current_arg], "modelname\0", 10) == 0) 
+            {
+                rc = ipmi_lcd_configure_wh (intf, IPMI_DELL_LCD_CONFIG_DEFAULT,0xFF,0XFF, 0, NULL);
+            }
+            else if (strncmp(argv[current_arg], "userdefined\0", 12) == 0) 
+            {
+                current_arg++;
+                if (argc <= current_arg) 
+                {
+                    ipmi_lcd_usage();return -1;
+                }
+                rc = ipmi_lcd_configure_wh (intf, IPMI_DELL_LCD_CONFIG_USER_DEFINED,0xFF,0XFF, line_number, argv[current_arg]);
+            }
+            else if (strncmp(argv[current_arg], "ipv4address\0", 12) == 0) 
+            {
+                rc = ipmi_lcd_configure_wh (intf, IPMI_DELL_LCD_iDRAC_IPV4ADRESS  ,0xFF,0XFF, 0, NULL);
+            }
+            else if (strncmp(argv[current_arg], "macaddress\0", 11) == 0) 
+            {
+                rc = ipmi_lcd_configure_wh (intf, IPMI_DELL_LCD_IDRAC_MAC_ADDRESS,0xFF,0XFF, 0, NULL);
+            }
+            else if (strncmp(argv[current_arg], "systemname\0", 11) == 0) 
+            {
+                rc = ipmi_lcd_configure_wh (intf, IPMI_DELL_LCD_OS_SYSTEM_NAME,0xFF,0XFF, 0, NULL);
+            }
+            else if (strncmp(argv[current_arg], "servicetag\0", 11) == 0) 
+            {
+                rc = ipmi_lcd_configure_wh (intf, IPMI_DELL_LCD_SERVICE_TAG, 0xFF,0XFF,0, NULL);
+            }
+            else if (strncmp(argv[current_arg], "ipv6address\0", 12) == 0) 
+            {
+                rc = ipmi_lcd_configure_wh (intf, IPMI_DELL_LCD_iDRAC_IPV6ADRESS  ,0xFF,0XFF, 0, NULL);
+            }
+            else if (strncmp(argv[current_arg], "ambienttemp\0", 12) == 0) 
+            {
+                rc = ipmi_lcd_configure_wh (intf, IPMI_DELL_LCD_AMBEINT_TEMP, 0xFF,0XFF,0, NULL);
+
+            }
+            else if (strncmp(argv[current_arg], "systemwatt\0", 11) == 0) 
+            {
+                rc = ipmi_lcd_configure_wh (intf, IPMI_DELL_LCD_SYSTEM_WATTS , 0xFF,0XFF,0, NULL);
+
+            }
+            else if (strncmp(argv[current_arg], "assettag\0", 9) == 0) 
+            {
+                rc = ipmi_lcd_configure_wh (intf, IPMI_DELL_LCD_ASSET_TAG , 0xFF,0XFF,0, NULL);
+
+            }
+            else if (strncmp(argv[current_arg], "help\0", 5) == 0) 
+            {
+                ipmi_lcd_usage();
+            }
+            else
+            {       
+                ipmi_lcd_usage();
+            }
+        }
+		else if ((strncmp(argv[current_arg], "lcdqualifier\0", 13)== 0) &&((iDRAC_FLAG==IDRAC_11G) || (iDRAC_FLAG==IDRAC_12G) ) )
+        {
+
+            current_arg++;
+            if (argc <= current_arg) 
+            {
+                ipmi_lcd_usage();
+                return -1;
+            }
+            if (argv[current_arg] == NULL) 
+            {
+                ipmi_lcd_usage();
+                return -1;
+            } 
+
+            if (strncmp(argv[current_arg], "watt\0", 5) == 0) {
+
+
+                rc = ipmi_lcd_configure_wh (intf, 0xFF,0x00,0XFF, 0, NULL);
+            }
+            else if (strncmp(argv[current_arg], "btuphr\0",7) == 0) {
+                rc = ipmi_lcd_configure_wh (intf, 0xFF,0x01,0XFF, 0, NULL);
+
+            } else if (strncmp(argv[current_arg], "celsius\0", 8) == 0) {
+                rc = ipmi_lcd_configure_wh (intf, 0xFF,0x02,0xFF, 0, NULL);
+            } else if (strncmp(argv[current_arg], "fahrenheit", 11) == 0) {
+                rc = ipmi_lcd_configure_wh (intf, 0xFF,0x03,0xFF, 0, NULL);
+
+            }else if (strncmp(argv[current_arg], "help\0", 5) == 0) {
+                ipmi_lcd_usage();
+            }
+            else {  
+                ipmi_lcd_usage();
+            }
+        }
+		else if( (strncmp(argv[current_arg], "errordisplay\0", 13) == 0)&&((iDRAC_FLAG==IDRAC_11G) || (iDRAC_FLAG==IDRAC_12G) )) 
+        {
+
+            current_arg++;
+            if (argc <= current_arg)
+            {
+                ipmi_lcd_usage();
+                return -1;
+            }
+            if (argv[current_arg] == NULL) 
+            { 
+                ipmi_lcd_usage();
+                return -1;
+            } 
+
+            if (strncmp(argv[current_arg], "sel\0", 4) == 0) 
+            {
+                rc = ipmi_lcd_configure_wh (intf, 0xFF,0xFF,IPMI_DELL_LCD_ERROR_DISP_SEL , 0, NULL);
+            }
+            else if (strncmp(argv[current_arg], "simple\0", 7) == 0) 
+            {
+                rc = ipmi_lcd_configure_wh (intf, 0xFF,0xFF,IPMI_DELL_LCD_ERROR_DISP_VERBOSE , 0, NULL);
+
+            }
+            else if (strncmp(argv[current_arg], "help\0", 5) == 0) 
+            {
+                ipmi_lcd_usage();
+            }
+            else 
+            {       
+                ipmi_lcd_usage();
+            }
+        }
+
+        else if ((strncmp(argv[current_arg], "none\0", 5) == 0)&&(iDRAC_FLAG==0)) 
+        {
+            rc = ipmi_lcd_configure (intf, IPMI_DELL_LCD_CONFIG_NONE, 0, NULL);
+        }
+        else if ((strncmp(argv[current_arg], "default\0", 8) == 0)&&(iDRAC_FLAG==0)) 
+        {
+            rc = ipmi_lcd_configure (intf, IPMI_DELL_LCD_CONFIG_DEFAULT, 0, NULL);
+
+        } 
+        else if ((strncmp(argv[current_arg], "custom\0", 7) == 0)&&(iDRAC_FLAG==0))  
+        {
+            current_arg++;
+            if (argc <= current_arg) 
+            {
+                ipmi_lcd_usage();
+                return -1;
+            }
+            rc = ipmi_lcd_configure (intf, IPMI_DELL_LCD_CONFIG_USER_DEFINED, line_number, argv[current_arg]);
+        } 
+
+        else if (strncmp(argv[current_arg], "vkvm\0", 5) == 0) 
+        {
+            current_arg++;
+            if (argc <= current_arg) 
+            {
+                ipmi_lcd_usage();
+                return -1;
+            }
+
+            if (strncmp(argv[current_arg], "active\0", 7) == 0) 
+            {
+                rc = ipmi_lcd_set_kvm (intf, 1);
+            }
+            else if (strncmp(argv[current_arg], "inactive\0", 9)==0)
+            {
+                rc = ipmi_lcd_set_kvm (intf, 0);
+
+            }
+            else if (strncmp(argv[current_arg], "help\0", 5) == 0) 
+            {
+                ipmi_lcd_usage();
+            }
+            else 
+            {       
+                ipmi_lcd_usage();
+            }
+
+        }
+        else if (strncmp(argv[current_arg], "frontpanelaccess\0", 17) == 0) 
+        {
+            current_arg++;
+            if (argc <= current_arg) 
+            {
+                ipmi_lcd_usage();
+                return -1;
+            }
+            if (strncmp(argv[current_arg], "viewandmodify\0", 14) == 0) 
+            {
+                rc = ipmi_lcd_set_lock (intf, 0);
+            }
+            else if (strncmp(argv[current_arg], "viewonly\0", 9)==0)
+            {
+                rc =  ipmi_lcd_set_lock (intf, 1);
+
+            }
+            else if (strncmp(argv[current_arg], "disabled\0", 9)==0)
+            {
+                rc =  ipmi_lcd_set_lock (intf, 2);
+
+            }
+            else if (strncmp(argv[current_arg], "help\0", 5) == 0) 
+            {
+                ipmi_lcd_usage();
+            }
+            else 
+            {       
+                ipmi_lcd_usage();
+            }
+
+        }
+        else if( (strncmp(argv[current_arg], "help\0", 5) == 0)&&(iDRAC_FLAG==0))  
+        {
+            ipmi_lcd_usage();
+        }
+        else 
+        {
+            ipmi_lcd_usage();
+            return -1;
+        }
+    } 
+    else 
+    {
+        ipmi_lcd_usage();
+        return -1;
+    }
+    return(rc);
+}
+
+
+
+/*****************************************************************
+* Function Name:      ipmi_lcd_get_platform_model_name
+*
+* Description: This function retrieves the platform model name, or any other parameter 
+*              which stores  data in the same format
+* Input:       intf         - pointer to interface
+*              max_length   - length of the platform model string
+*              field_type   - either hostname / platform model
+* Output:      lcdstring    - hostname / platform model string
+*
+* Return:            
+*
+******************************************************************/ 
+static int
+ipmi_lcd_get_platform_model_name (void * intf, 
+                          char* lcdstring, 
+                                  uint8_t max_length, 
+                                  uint8_t field_type)
+{
+    uint8_t rsp[IPMI_RSPBUF_SIZE];
+    int rsp_len, rv;
+    struct ipmi_rq req = {0};
+    uint8_t data[4];
+    IPMI_DELL_LCD_STRING * lcdstringblock;
+    int lcdstring_len = 0;
+    int bytes_copied = 0;
+
+    int ii;
+
+    for (ii = 0; ii < 4; ii++)
+    {
+        int bytes_to_copy;
+		memset (&req,0,sizeof(req));
+        req.msg.netfn = IPMI_NETFN_APP;
+        req.msg.lun = 0;
+        req.msg.cmd = IPMI_GET_SYS_INFO;
+        req.msg.data_len = 4;
+        req.msg.data = data;
+        data[0] = 0;                            /* get parameter*/
+        data[1] = field_type;
+        data[2] = ii;
+        data[3] = 0;
+
+
+	rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+	if (rv) {
+	   printf("Error getting platform model name: ");
+	   if (rv < 0) printf("no response\n");
+	   else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+	   return rv;
+        }
+
+        lcdstringblock = (IPMI_DELL_LCD_STRING *) (void *) rsp;
+
+        /* first block is different - 14 bytes*/
+        if (0 == ii) {
+            lcdstring_len = lcdstringblock->lcd_string.selector_0_string.length;
+
+            lcdstring_len = MIN (lcdstring_len,max_length);
+
+            bytes_to_copy = MIN(lcdstring_len, IPMI_DELL_LCD_STRING1_SIZE);
+            memcpy (lcdstring, lcdstringblock->lcd_string.selector_0_string.data, bytes_to_copy);
+        } else {
+            int string_offset;
+
+            bytes_to_copy = MIN(lcdstring_len - bytes_copied, IPMI_DELL_LCD_STRINGN_SIZE);
+            if (bytes_to_copy < 1)
+                break;
+            string_offset = IPMI_DELL_LCD_STRING1_SIZE + IPMI_DELL_LCD_STRINGN_SIZE * (ii-1);
+            memcpy (lcdstring+string_offset, lcdstringblock->lcd_string.selector_n_data, bytes_to_copy);
+        }
+
+
+        bytes_copied += bytes_to_copy;
+
+        if (bytes_copied >= lcdstring_len)
+
+            break;
+    }
+    return rv;
+}
+
+/*****************************************************************
+* Function Name:    ipmi_idracvalidator_command
+*
+* Description:      This function returns the iDRAC6 type
+* Input:            intf            - ipmi interface
+* Output:       
+*
+* Return:           iDRAC6 type     1 - whoville 
+*                                   0 - others
+*
+******************************************************************/
+
+static int
+ipmi_idracvalidator_command (void * intf)
+{
+    uint8_t rsp[IPMI_RSPBUF_SIZE];
+    int rsp_len, rv;
+    struct ipmi_rq req = {0};
+    uint8_t data[4];
+
+    memset (&req,0,sizeof(req));
+    req.msg.netfn = IPMI_NETFN_APP;
+    req.msg.lun = 0;
+    req.msg.cmd = IPMI_GET_SYS_INFO;
+    req.msg.data_len = 4;
+    req.msg.data = data;
+    data[0] = 0;
+    data[1] = IPMI_DELL_IDRAC_VALIDATOR;
+    data[2] = 2;
+    data[3] = 0;
+
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv && fdebug) {
+        printf(" Error getting IMC type");
+        if (rv < 0) printf("no response\n");
+        else printf("Completion Code 0x%02x\n", rv);
+        return rv;
+    }
+    IMC_Type = rsp[10];
+    if( (IMC_Type == IMC_IDRAC_11G_MONOLITHIC) || (IMC_Type == IMC_IDRAC_11G_MODULAR) )
+    {
+		iDRAC_FLAG=IDRAC_11G;
+    }
+    else if( (IMC_Type == IMC_IDRAC_12G_MONOLITHIC) || (IMC_Type == IMC_IDRAC_12G_MODULAR) )
+    {
+		iDRAC_FLAG=IDRAC_12G;
+    }
+    else
+    {
+        iDRAC_FLAG=0;
+    }       
+    
+    return 0;
+}
+
+/*****************************************************************
+* Function Name:    ipmi_lcd_get_configure_command_wh
+*
+* Description:      This function returns current lcd configuration for Dell OEM LCD command
+* Input:            intf            - ipmi interface
+* Global:           lcd_mode - lcd mode setting
+* Output:    
+*
+* Return:           returns the current lcd configuration
+*                   0 = User defined
+*                   1 = Default
+*                   2 = None
+*
+******************************************************************/ 
+static int
+ipmi_lcd_get_configure_command_wh (void * intf)
+{
+    uint8_t rsp[IPMI_RSPBUF_SIZE];
+    int rsp_len, rv;
+    struct ipmi_rq req = {0};
+    uint8_t data[4];
+
+    req.msg.netfn = IPMI_NETFN_APP;
+    req.msg.lun = 0;
+    req.msg.cmd = IPMI_GET_SYS_INFO;
+    req.msg.data_len = 4;
+    req.msg.data = data;
+    data[0] = 0;
+    data[1] = IPMI_DELL_LCD_CONFIG_SELECTOR;
+    data[2] = 0;
+    data[3] = 0;
+
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+        printf("Error getting LCD configuration: ");
+        if (rv < 0) printf("no response\n");
+        else printf("Completion Code 0x%02x\n", rv);
+        return rv;
+    }
+
+    lcd_mode= *((LCD_MODE*)(&rsp[0]));
+    return 0;
+}
+
+
+/*****************************************************************
+* Function Name:    ipmi_lcd_get_configure_command
+*
+* Description:   This function returns current lcd configuration for Dell OEM LCD command
+* Input:         intf            - ipmi interface
+* Output:        command         - user defined / default / none / ipv4 / mac address / 
+                 system name / service tag / ipv6 / temp / system watt / asset tag
+*
+* Return:             
+*
+******************************************************************/
+
+static int
+ipmi_lcd_get_configure_command (void * intf,
+                                uint8_t *command)
+{
+    uint8_t rsp[IPMI_RSPBUF_SIZE];
+    int rsp_len, rv;
+    struct ipmi_rq req = {0};
+    uint8_t data[4];
+
+    req.msg.netfn = IPMI_NETFN_APP;
+    req.msg.lun = 0;
+    req.msg.cmd = IPMI_GET_SYS_INFO;
+    req.msg.data_len = 4;
+    req.msg.data = data;
+    data[0] = 0;
+    data[1] = IPMI_DELL_LCD_CONFIG_SELECTOR;
+    data[2] = 0;
+    data[3] = 0;
+
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+        printf("Error getting LCD configuration: ");
+        if (rv < 0) printf("no response\n");
+        else printf("Completion Code 0x%02x\n", rv);
+        return rv;
+    }
+
+    /* rsp->data[0] is the rev */
+    *command = rsp[1];
+
+    return 0;
+}
+
+/*****************************************************************
+* Function Name:    ipmi_lcd_set_configure_command
+*
+* Description:      This function updates current lcd configuration 
+* Input:            intf            - ipmi interface
+*                   command         - user defined / default / none / ipv4 / mac address / 
+*                        system name / service tag / ipv6 / temp / system watt / asset tag
+* Output:
+* Return:             
+*
+******************************************************************/
+
+static int
+ipmi_lcd_set_configure_command (void * intf, int command)
+{
+#define LSCC_DATA_LEN 2
+
+    uint8_t rsp[IPMI_RSPBUF_SIZE];
+    int rsp_len, rv;
+    struct ipmi_rq req = {0};
+    uint8_t data[2];
+
+    req.msg.netfn = IPMI_NETFN_APP;
+    req.msg.lun = 0;
+    req.msg.cmd = IPMI_SET_SYS_INFO;
+    req.msg.data_len = 2;
+    req.msg.data = data;
+    data[0] = IPMI_DELL_LCD_CONFIG_SELECTOR;
+    data[1] = command;                      /* command - custom, default, none */
+
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+        printf("Error setting LCD configuration: ");
+        if (rv < 0) printf("no response\n");
+        else printf("Completion Code 0x%02x\n", rv);
+        return rv;
+    }
+
+    return 0;
+}
+
+
+/*****************************************************************
+* Function Name:    ipmi_lcd_set_configure_command
+*
+* Description:      This function updates current lcd configuration 
+* Input:            intf            - ipmi interface
+*                   mode            - user defined / default / none 
+*                   lcdqualifier   - lcd quallifier id
+*                   errordisp       - error number
+* Output:
+* Return:                
+*
+******************************************************************/ 
+static int
+ipmi_lcd_set_configure_command_wh (void * intf, 
+                                   uint32_t  mode,
+                                   uint16_t lcdqualifier,
+                                   uint8_t errordisp)
+{
+#define LSCC_DATA_LEN 2
+
+    uint8_t rsp[IPMI_RSPBUF_SIZE];
+    int rsp_len, rv;
+    struct ipmi_rq req = {0};
+    uint8_t data[13];
+
+    ipmi_lcd_get_configure_command_wh(intf);
+    req.msg.netfn = IPMI_NETFN_APP;
+    req.msg.lun = 0;
+    req.msg.cmd = IPMI_SET_SYS_INFO;
+    req.msg.data_len = 13;
+    req.msg.data = data;
+    data[0] = IPMI_DELL_LCD_CONFIG_SELECTOR;
+
+    if(mode!=0xFF)
+    {
+
+        data[1] = mode&0xFF;                    /* command - custom, default, none*/
+        data[2]=(mode&0xFF00)>>8;
+        data[3]=(mode&0xFF0000)>>16;
+        data[4]=(mode&0xFF000000)>>24;
+    }
+    else
+    {
+        data[1] = (lcd_mode.lcdmode)&0xFF;                      /* command - custom, default, none*/
+        data[2]=((lcd_mode.lcdmode)&0xFF00)>>8;
+        data[3]=((lcd_mode.lcdmode)&0xFF0000)>>16;
+        data[4]=((lcd_mode.lcdmode)&0xFF000000)>>24;
+    }
+
+    if(lcdqualifier!=0xFF)
+    {
+        if(lcdqualifier==0x01)
+        {
+            data[5] =(lcd_mode.lcdqualifier)|0x01;                 /* command - custom, default, none*/
+
+        }
+        else  if(lcdqualifier==0x00)
+        {
+            data[5] =(lcd_mode.lcdqualifier)&0xFE;                 /* command - custom, default, none*/
+        }
+        else if (lcdqualifier==0x03)
+        {
+            data[5] =(lcd_mode.lcdqualifier)|0x02;                 /* command - custom, default, none*/
+        }
+        else if (lcdqualifier==0x02)
+        {
+            data[5] =(lcd_mode.lcdqualifier)&0xFD; 
+        }
+    }
+    else
+    {
+        data[5]=(uchar)lcd_mode.lcdqualifier;
+    }   
+    if(errordisp!=0xFF)
+    {
+        data[11]=errordisp;
+    }
+    else
+    {
+        data[11]=lcd_mode.error_display;
+    }
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+        printf("Error setting LCD configuration: ");
+        if (rv < 0) printf("no response\n");
+        else printf("Completion Code 0x%02x\n", rv);
+        return rv;
+    }
+
+    return 0;
+}
+
+
+
+/*****************************************************************
+* Function Name:    ipmi_lcd_get_single_line_text
+*
+* Description:    This function updates current lcd configuration 
+* Input:          intf            - ipmi interface
+*                 lcdstring       - new string to be updated 
+*                 max_length      - length of the string
+* Output:
+* Return:              
+*
+******************************************************************/
+
+static int
+ipmi_lcd_get_single_line_text (void * intf, char* lcdstring, uint8_t max_length)
+{
+    uint8_t rsp[IPMI_RSPBUF_SIZE];
+    int rsp_len, rv;
+    struct ipmi_rq req = {0};
+    uint8_t data[4];
+    IPMI_DELL_LCD_STRING * lcdstringblock;
+    int lcdstring_len = 0;
+    int bytes_copied = 0;
+    int ii;
+
+    for (ii = 0; ii < 4; ii++) {
+        int bytes_to_copy;
+
+        req.msg.netfn = IPMI_NETFN_APP;
+        req.msg.lun = 0;
+        req.msg.cmd = IPMI_GET_SYS_INFO;
+        req.msg.data_len = 4;
+        req.msg.data = data;
+        data[0] = 0;                            /* get parameter*/
+        data[1] = IPMI_DELL_LCD_STRING_SELECTOR;
+        data[2] = ii;                           /* block selector*/
+        data[3] = 0;                            /* set selector (n/a)*/
+
+	rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+	if (rv) {
+	   printf("Error getting text data: ");
+	   if (rv < 0) printf("no response\n");
+	   else printf("Completion Code 0x%02x\n", rv);
+	   return rv;
+	}
+
+        lcdstringblock = (IPMI_DELL_LCD_STRING *) (void *) rsp;
+
+        /* first block is different - 14 bytes*/
+        if (0 == ii)
+        {
+            lcdstring_len = lcdstringblock->lcd_string.selector_0_string.length;
+
+            if (lcdstring_len < 1 || lcdstring_len > max_length)
+                break;
+
+            bytes_to_copy = MIN(lcdstring_len, IPMI_DELL_LCD_STRING1_SIZE);
+            memcpy (lcdstring, lcdstringblock->lcd_string.selector_0_string.data, bytes_to_copy);
+        }
+        else
+        {
+            int string_offset;
+
+            bytes_to_copy = MIN(lcdstring_len - bytes_copied, IPMI_DELL_LCD_STRINGN_SIZE);
+            if (bytes_to_copy < 1)
+                break;
+            string_offset = IPMI_DELL_LCD_STRING1_SIZE + IPMI_DELL_LCD_STRINGN_SIZE * (ii-1);
+            memcpy (lcdstring+string_offset, lcdstringblock->lcd_string.selector_n_data, bytes_to_copy);
+        }
+
+        bytes_copied += bytes_to_copy;
+        if (bytes_copied >= lcdstring_len)
+            break;
+    }
+    return 0;
+}
+
+/*****************************************************************
+* Function Name:    ipmi_lcd_get_info_wh
+*
+* Description:     This function prints current lcd configuration for whoville platform
+* Input:           intf            - ipmi interface
+* Output:
+* Return:              
+*
+******************************************************************/
+
+static int
+ipmi_lcd_get_info_wh(void * intf)
+
+{
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req = {0};
+    uint8_t data[4];
+    uint8_t command = 0;
+    IPMI_DELL_LCD_CAPS* lcd_caps;
+    char lcdstring[IPMI_DELL_LCD_STRING_LENGTH_MAX+1] = {0};
+    int rc;
+
+
+    printf("LCD info\n");
+
+    if (ipmi_lcd_get_configure_command_wh (intf) != 0) 
+    {
+        return -1;
+    }
+    else 
+    {
+        if (lcd_mode.lcdmode== IPMI_DELL_LCD_CONFIG_DEFAULT) 
+        {
+            char text[IPMI_DELL_LCD_STRING_LENGTH_MAX+1] = {0};
+
+            ipmi_lcd_get_platform_model_name(intf, text, 
+                IPMI_DELL_LCD_STRING_LENGTH_MAX,
+                IPMI_DELL_PLATFORM_MODEL_NAME_SELECTOR);
+
+            if (text == NULL)
+                return -1;
+            printf("    Setting:Model name\n");
+            printf("    Line 1:  %s\n", text);
+        }
+        else if (lcd_mode.lcdmode == IPMI_DELL_LCD_CONFIG_NONE) 
+        {
+            printf("    Setting:   none\n");
+        }
+        else if (lcd_mode.lcdmode == IPMI_DELL_LCD_CONFIG_USER_DEFINED) 
+        {
+            req.msg.netfn = IPMI_NETFN_APP;
+            req.msg.lun = 0;
+            req.msg.cmd = IPMI_GET_SYS_INFO;
+            req.msg.data_len = 4;
+            req.msg.data = data;
+            data[0] = 0;                            /* get parameter*/
+            data[1] = IPMI_DELL_LCD_GET_CAPS_SELECTOR;
+            data[2] = 0;                            /* set selector (n/a)*/
+            data[3] = 0;                            /* block selector (n/a)*/
+
+            printf("    Setting: User defined\n");
+
+            rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+        printf("Error getting LCD capabilities: ");
+        if (rv < 0) printf("no response\n");
+        else printf("Completion Code 0x%02x\n", rv);
+        return rv;
+    }
+
+            lcd_caps = (IPMI_DELL_LCD_CAPS *)rsp;
+            if (lcd_caps->number_lines > 0) 
+            {
+                memset(lcdstring, 0, IPMI_DELL_LCD_STRING_LENGTH_MAX+1);
+
+                rc = ipmi_lcd_get_single_line_text (intf, lcdstring, lcd_caps->max_chars[0]);
+                printf("    Text:    %s\n", lcdstring);
+            }
+            else 
+            {
+                printf("    No lines to show\n");
+            }
+        }
+        else if (lcd_mode.lcdmode == IPMI_DELL_LCD_iDRAC_IPV4ADRESS) 
+        {
+            printf("    Setting:   IPV4 Address\n");
+        }
+        else if (lcd_mode.lcdmode == IPMI_DELL_LCD_IDRAC_MAC_ADDRESS) 
+        {
+            printf("    Setting:   MAC Address\n");
+        }
+        else if (lcd_mode.lcdmode == IPMI_DELL_LCD_OS_SYSTEM_NAME) 
+        {
+            printf("    Setting:   OS System Name\n");
+        }
+        else if (lcd_mode.lcdmode == IPMI_DELL_LCD_SERVICE_TAG) 
+        {
+            printf("    Setting:   System Tag\n");
+        }
+        else if (lcd_mode.lcdmode == IPMI_DELL_LCD_iDRAC_IPV6ADRESS) 
+        {
+            printf("    Setting:  IPV6 Address\n");
+        }
+        else if (lcd_mode.lcdmode == IPMI_DELL_LCD_AMBEINT_TEMP) 
+        {
+            printf("    Setting:  Ambient Temp\n");
+            if(lcd_mode.lcdqualifier&0x02)
+                printf("    Unit:  F\n");  
+            else
+                printf("    Unit:  C\n");  
+        }
+        else if (lcd_mode.lcdmode == IPMI_DELL_LCD_SYSTEM_WATTS)
+        {
+            printf("    Setting:  System Watts\n");
+
+            if(lcd_mode.lcdqualifier&0x01)
+                printf("    Unit:  BTU/hr\n");  
+            else
+                printf("    Unit:  Watt\n"); 
+
+        }
+        if(lcd_mode.error_display==IPMI_DELL_LCD_ERROR_DISP_SEL)
+            printf("    Error Display:  SEL\n");
+        else if(lcd_mode.error_display==IPMI_DELL_LCD_ERROR_DISP_VERBOSE)
+            printf("    Error Display:  Simple\n");
+    }
+
+    return 0;
+}
+
+/*****************************************************************
+* Function Name:    ipmi_lcd_get_info
+*
+* Description:      This function prints current lcd configuration for platform other than whoville
+* Input:            intf            - ipmi interface
+* Output:
+* Return:              
+*
+******************************************************************/
+static int ipmi_lcd_get_info(void * intf)
+{
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req = {0};
+    uint8_t data[4];
+    IPMI_DELL_LCD_CAPS * lcd_caps;
+    uint8_t command = 0;
+    char lcdstring[IPMI_DELL_LCD_STRING_LENGTH_MAX+1] = {0};
+    int rc; 
+
+    printf("LCD info\n");
+
+    if (ipmi_lcd_get_configure_command (intf, &command) != 0)
+    {
+        return -1;
+    }
+    else
+    {
+        if (command == IPMI_DELL_LCD_CONFIG_DEFAULT)
+        {
+            memset (lcdstring,0,IPMI_DELL_LCD_STRING_LENGTH_MAX+1);
+
+            ipmi_lcd_get_platform_model_name(intf, lcdstring, IPMI_DELL_LCD_STRING_LENGTH_MAX,
+                IPMI_DELL_PLATFORM_MODEL_NAME_SELECTOR);
+
+            printf("    Setting: default\n");
+            printf("    Line 1:  %s\n", lcdstring);
+        }
+        else if (command == IPMI_DELL_LCD_CONFIG_NONE)
+        {
+            printf("    Setting:   none\n");
+        }
+        else if (command == IPMI_DELL_LCD_CONFIG_USER_DEFINED)
+        {
+            req.msg.netfn = IPMI_NETFN_APP;
+            req.msg.lun = 0;
+            req.msg.cmd = IPMI_GET_SYS_INFO;
+            req.msg.data_len = 4;
+            req.msg.data = data;
+            data[0] = 0;                            /* get parameter */
+            data[1] = IPMI_DELL_LCD_GET_CAPS_SELECTOR;
+            data[2] = 0;                            /* set selector (n/a) */
+            data[3] = 0;                            /* block selector (n/a) */
+
+            printf("    Setting: custom\n");
+
+            rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+        printf("Error getting LCD capabilities: ");
+        if (rv < 0) printf("no response\n");
+        else printf("Completion Code 0x%02x\n", rv);
+        return rv;
+    }
+
+            lcd_caps = (IPMI_DELL_LCD_CAPS *)(void *)rsp;
+            if (lcd_caps->number_lines > 0)
+            {
+                memset (lcdstring,0,IPMI_DELL_LCD_STRING_LENGTH_MAX+1);
+                rc = ipmi_lcd_get_single_line_text (intf, lcdstring, lcd_caps->max_chars[0]);
+                printf("    Text:    %s\n", lcdstring);
+            }
+            else
+            {
+                printf("    No lines to show\n");
+            }
+        }
+    }
+
+    return 0;
+}
+
+/*****************************************************************
+* Function Name:    ipmi_lcd_get_status_val
+*
+* Description:      This function gets current lcd configuration 
+* Input:            intf            - ipmi interface
+* Output:           lcdstatus       - KVM Status & Lock Status
+* Return:           
+*
+******************************************************************/
+
+static int
+ipmi_lcd_get_status_val(void * intf, LCD_STATUS* lcdstatus)
+{
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req = {0};
+    uint8_t data[4];
+
+
+    req.msg.netfn = IPMI_NETFN_APP;
+    req.msg.lun = 0;
+    req.msg.cmd = IPMI_GET_SYS_INFO;
+    req.msg.data_len = 4;
+    req.msg.data = data;
+    data[0] = 0;                            /* get parameter */
+    data[1] = IPMI_DELL_LCD_STATUS_SELECTOR;
+    data[2] = 0;                            /* block selector */
+    data[3] = 0;            
+    /* set selector (n/a) */
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+        printf("Error getting LCD status: ");
+        if (rv < 0) printf("no response\n");
+        else printf("Completion Code 0x%02x\n", rv);
+        return rv;
+    }
+
+    /*lcdstatus= (LCD_STATUS* ) rsp->data; */
+
+    lcdstatus->vKVM_status=rsp[1];
+    lcdstatus->lock_status=rsp[2];
+
+    return 0;
+}
+
+
+/*****************************************************************
+* Function Name:    IsLCDSupported
+*
+* Description:   This function returns whether lcd supported or not
+* Input:              
+* Output:       
+* Return:               
+*
+******************************************************************/
+static int IsLCDSupported ()
+{
+    return LcdSupported;
+}
+
+/*****************************************************************
+* Function Name:         CheckLCDSupport
+*
+* Description:  This function checks whether lcd supported or not
+* Input:        intf            - ipmi interface
+* Output:       
+* Return:               
+*
+******************************************************************/
+static void CheckLCDSupport(void * intf)
+{
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req = {0};
+    uint8_t data[4];
+
+    LcdSupported = 0;
+
+    req.msg.netfn = IPMI_NETFN_APP;
+    req.msg.lun = 0;
+    req.msg.cmd = IPMI_GET_SYS_INFO;
+    req.msg.data_len = 4;
+    req.msg.data = data;
+    data[0] = 0;                            /* get parameter */
+    data[1] = IPMI_DELL_LCD_STATUS_SELECTOR;
+    data[2] = 0;                            /* block selector */
+    data[3] = 0;            
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) { return; }
+    LcdSupported = 1;       
+
+}
+
+/*****************************************************************
+* Function Name:     ipmi_lcd_status_print
+*
+* Description:    This function prints current lcd configuration KVM Status & Lock Status
+* Input:          lcdstatus - KVM Status & Lock Status
+* Output:   
+* Return:               
+*
+******************************************************************/
+
+static void ipmi_lcd_status_print( LCD_STATUS lcdstatus)
+{
+    switch (lcdstatus.vKVM_status)
+    {
+    case 0x00: 
+        printf("LCD KVM Status :Inactive\n");
+        break;
+    case 0x01: 
+        printf("LCD KVM Status :Active\n");
+        break;
+    default:
+        printf("LCD KVM Status :Invalid Status\n");
+
+        break;
+    }                       
+
+    switch (lcdstatus.lock_status)
+    {
+    case 0x00: 
+        printf("LCD lock Status :View and modify\n");
+        break;
+    case 0x01: 
+        printf("LCD lock Status :View only\n");
+        break;
+    case 0x02:
+        printf("LCD lock Status :disabled\n");
+        break;
+    default:
+        printf("LCD lock Status :Invalid\n");
+        break;
+    }
+
+}
+
+/*****************************************************************
+* Function Name:     ipmi_lcd_get_status
+*
+* Description:      This function gets current lcd KVM active status & lcd access mode
+* Input:            intf            - ipmi interface
+* Output:       
+* Return:           -1 on error
+*                   0 if successful
+*
+******************************************************************/
+static int
+ipmi_lcd_get_status(void * intf )
+{
+    int rc=0;
+    LCD_STATUS  lcdstatus;
+
+    rc =ipmi_lcd_get_status_val( intf, &lcdstatus);
+    if (rc <0)
+        return -1;
+    ipmi_lcd_status_print(lcdstatus);
+
+    return rc;
+
+}
+
+/*****************************************************************
+* Function Name:     ipmi_lcd_set_kvm
+*
+* Description:       This function sets lcd KVM active status 
+* Input:             intf            - ipmi interface
+*                    status  - Inactive / Active
+* Output:    
+* Return:            -1 on error
+*                    0 if successful
+*
+******************************************************************/ 
+static int
+ipmi_lcd_set_kvm(void * intf, char status)
+{
+#define LSCC_DATA_LEN 2
+    LCD_STATUS lcdstatus;
+    int rc=0;
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req = {0};
+    uint8_t data[5];
+    rc=ipmi_lcd_get_status_val(intf,&lcdstatus);
+    if (rc < 0)
+        return -1;
+    req.msg.netfn = IPMI_NETFN_APP;
+    req.msg.lun = 0;
+    req.msg.cmd = IPMI_SET_SYS_INFO;
+    req.msg.data_len = 5;
+    req.msg.data = data;
+    data[0] = IPMI_DELL_LCD_STATUS_SELECTOR;
+    data[1] = status;                       /* active- incative*/
+    data[2] = lcdstatus.lock_status;        /* full-veiw-locked */
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+        printf("Error setting LCD status: ");
+        if (rv < 0) printf("no response\n");
+        else printf("Completion Code 0x%02x\n", rv);
+        return rv;
+    }
+
+    return rc;
+}
+
+/*****************************************************************
+* Function Name:   ipmi_lcd_set_lock
+*
+* Description:     This function sets lcd access mode 
+* Input:           intf            - ipmi interface
+*                  lock    - View and modify / View only / Diabled
+* Output:        
+* Return:          -1 on error
+*                  0 if successful
+*
+******************************************************************/ 
+static int
+ipmi_lcd_set_lock(void * intf,  char lock)
+{
+#define LSCC_DATA_LEN 2
+    LCD_STATUS lcdstatus;
+    int rc =0;
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req = {0};
+    uint8_t data[5];
+    rc=ipmi_lcd_get_status_val(intf,&lcdstatus);
+    if (rc < 0)
+        return -1;
+    req.msg.netfn = IPMI_NETFN_APP;
+    req.msg.lun = 0;
+    req.msg.cmd = IPMI_SET_SYS_INFO;
+    req.msg.data_len = 5;
+    req.msg.data = data;
+    data[0] = IPMI_DELL_LCD_STATUS_SELECTOR;
+    data[1] = lcdstatus.vKVM_status;                        /* active- incative */
+    data[2] = lock;                 /* full- veiw-locked */
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+        printf("Error setting LCD status: ");
+        if (rv < 0) printf("no response\n");
+        else printf("Completion Code 0x%02x\n", rv);
+        return rv;
+    }
+
+    return rc;
+}
+
+/*****************************************************************
+* Function Name:   ipmi_lcd_set_single_line_text
+*
+* Description:    This function sets lcd line text
+* Input:          intf            - ipmi interface
+*                 text    - lcd string
+* Output:   
+* Return:         -1 on error
+*                 0 if successful
+*
+******************************************************************/
+
+static int 
+ipmi_lcd_set_single_line_text (void * intf, char * text)
+{
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req = {0};
+    uint8_t data[18];
+    int bytes_to_store = strlen_(text);
+    int bytes_stored = 0;
+    int ii;
+    int rc = 0;
+    if (bytes_to_store>IPMI_DELL_LCD_STRING_LENGTH_MAX)
+    {
+        lprintf(LOG_ERR, " Out of range Max limit is 62 characters");
+        return 1;
+
+    }
+    else
+    {
+        bytes_to_store = MIN(bytes_to_store, IPMI_DELL_LCD_STRING_LENGTH_MAX);
+        for (ii = 0; ii < 4; ii++) {
+            /*first block, 2 bytes parms and 14 bytes data*/
+            if (0 == ii) {
+                int size_of_copy =  
+                    MIN((bytes_to_store - bytes_stored), IPMI_DELL_LCD_STRING1_SIZE);
+                if (size_of_copy < 0)           /* allow 0 string length*/
+                    break;
+                req.msg.netfn = IPMI_NETFN_APP;
+                req.msg.lun = 0;
+                req.msg.cmd = IPMI_SET_SYS_INFO;
+                req.msg.data_len = size_of_copy + 4; /* chars, selectors and sizes*/
+                req.msg.data = data;
+                data[0] = IPMI_DELL_LCD_STRING_SELECTOR;
+                data[1] = ii;                           /* block number to use (0)*/
+                data[2] = 0;                            /*string encoding*/
+                data[3] = bytes_to_store;       /* total string length*/
+                memcpy (data+4, text+bytes_stored, size_of_copy);
+                bytes_stored += size_of_copy;
+            } else {
+                int size_of_copy =  
+                    MIN((bytes_to_store - bytes_stored), IPMI_DELL_LCD_STRINGN_SIZE);
+                if (size_of_copy <= 0)
+                    break;
+                req.msg.netfn = IPMI_NETFN_APP;
+                req.msg.lun = 0;
+                req.msg.cmd = IPMI_SET_SYS_INFO;
+                req.msg.data_len = size_of_copy + 2;
+                req.msg.data = data;
+                data[0] = IPMI_DELL_LCD_STRING_SELECTOR;
+                data[1] = ii;                           /* block number to use (1,2,3)*/
+                memcpy (data+2, text+bytes_stored, size_of_copy);
+                bytes_stored += size_of_copy;
+            }
+
+            rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+        printf("Error setting text data: ");
+        if (rv < 0) printf("no response\n");
+        else printf("Completion Code 0x%02x\n", rv);
+        return rv;
+    }
+        }
+    }
+    return rc;
+}
+
+/*****************************************************************
+* Function Name:   ipmi_lcd_set_text
+*
+* Description:     This function sets lcd line text
+* Input:           intf            - ipmi interface
+*                  text    - lcd string
+*                  line_number- line number
+
+* Output:       
+* Return:          -1 on error
+*                  0 if successful
+*
+******************************************************************/
+
+static int
+ipmi_lcd_set_text(void * intf, char * text, int line_number)
+{
+    int rc = 0;
+
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req = {0};
+    uint8_t data[4];
+    IPMI_DELL_LCD_CAPS * lcd_caps;
+
+    req.msg.netfn = IPMI_NETFN_APP;
+    req.msg.lun = 0;
+    req.msg.cmd = IPMI_GET_SYS_INFO;
+    req.msg.data_len = 4;
+    req.msg.data = data;
+    data[0] = 0;                            /* get parameter*/
+    data[1] = IPMI_DELL_LCD_GET_CAPS_SELECTOR;
+    data[2] = 0;                            /* set selector (n/a)*/
+    data[3] = 0;                            /* block selector (n/a)*/
+
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+        printf("Error getting LCD capabilities: ");
+        if (rv < 0) printf("no response\n");
+        else printf("Completion Code 0x%02x\n", rv);
+        return rv;
+    }
+
+    lcd_caps = (IPMI_DELL_LCD_CAPS *)(void *)rsp;
+
+    if (lcd_caps->number_lines > 0) {
+        rc = ipmi_lcd_set_single_line_text (intf, text);
+    } else {
+        lprintf(LOG_ERR, "LCD does not have any lines that can be set");
+        rc = -1;
+    }
+
+
+    return rc;
+}
+
+/*****************************************************************
+* Function Name:   ipmi_lcd_configure_wh
+*
+* Description:     This function updates the current lcd configuration
+* Input:           intf            - ipmi interface
+*                  lcdqualifier- lcd quallifier
+*                  errordisp       - error number
+*                  line_number-line number
+*                  text            - lcd string
+* Output:   
+* Return:          -1 on error
+*                  0 if successful
+*
+******************************************************************/
+
+static int
+ipmi_lcd_configure_wh (void * intf, uint32_t  mode ,
+                       uint16_t lcdqualifier, uint8_t errordisp, 
+                       int8_t line_number, char * text)
+{
+    int rc = 0;
+
+
+    if (IPMI_DELL_LCD_CONFIG_USER_DEFINED == mode)
+        /* Any error was reported earlier. */
+        rc = ipmi_lcd_set_text(intf, text, line_number);
+
+
+    if (rc == 0)
+
+        rc = ipmi_lcd_set_configure_command_wh (intf, mode ,lcdqualifier,errordisp);
+
+    return rc;
+}
+
+
+/*****************************************************************
+* Function Name:   ipmi_lcd_configure
+*
+* Description:     This function updates the current lcd configuration
+* Input:           intf            - ipmi interface
+*                  command- lcd command
+*                  line_number-line number
+*                  text            - lcd string
+* Output:   
+* Return:          -1 on error
+*                  0 if successful
+*
+******************************************************************/
+
+static int
+ipmi_lcd_configure (void * intf, int command, 
+                    int8_t line_number, char * text)
+{
+    int rc = 0;
+
+    if (IPMI_DELL_LCD_CONFIG_USER_DEFINED == command)
+        rc = ipmi_lcd_set_text(intf, text, line_number);
+
+    if (rc == 0)
+        rc = ipmi_lcd_set_configure_command (intf, command);
+
+    return rc;
+}
+
+
+/*****************************************************************
+* Function Name:   ipmi_lcd_usage
+*
+* Description:   This function prints help message for lcd command
+* Input:               
+* Output:       
+*
+* Return:              
+*
+******************************************************************/
+
+static void
+ipmi_lcd_usage(void)
+{
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "Generic DELL HW:");
+    lprintf(LOG_NOTICE, "   lcd set {none}|{default}|{custom <text>}");
+    lprintf(LOG_NOTICE, "      Set LCD text displayed during non-fault conditions");
+
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "iDRAC 11g or iDRAC 12g:");
+    lprintf(LOG_NOTICE, "   lcd set {mode}|{lcdqualifier}|{errordisplay}");
+    lprintf(LOG_NOTICE, "      Allows you to set the LCD mode and user-definedstring.");
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "   lcd set mode {none}|{modelname}|{ipv4address}|{macaddress}|");
+    lprintf(LOG_NOTICE, "   {systemname}|{servicetag}|{ipv6address}|{ambienttemp}");
+    lprintf(LOG_NOTICE, "   {systemwatt }|{assettag}|{userdefined}<text>");
+    lprintf(LOG_NOTICE, "         Allows you to set the LCD display mode to any of the preceding parameters");
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "   lcd set lcdqualifier {watt}|{btuphr}|{celsius}|{fahrenheit}");
+    lprintf(LOG_NOTICE, "      Allows you to set the unit for the system ambient temperature mode.");
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "   lcd set errordisplay {sel}|{simple}");
+    lprintf(LOG_NOTICE, "      Allows you to set the error display.");
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "   lcd info");
+    lprintf(LOG_NOTICE, "      Show LCD text that is displayed during non-fault conditions");
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "   lcd set vkvm{active}|{inactive}");
+    lprintf(LOG_NOTICE, "           Set vKVM active and inactive, message will be displayed on lcd"); 
+    lprintf(LOG_NOTICE, " when vKVM is active and vKVM session is in progress");
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "   lcd set frontpanelaccess {viewandmodify}|{viewonly}|{disabled}");
+    lprintf(LOG_NOTICE, "      Set LCD mode to view and modify, view only or disabled ");
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "   lcd status");
+    lprintf(LOG_NOTICE, "           Show LCD Status for vKVM display<active|inactive>");
+    lprintf(LOG_NOTICE, "   and Front Panel access mode {viewandmodify}|{viewonly}|{disabled} ");
+    lprintf(LOG_NOTICE, "");
+}
+
+/*****************************************************************
+* Function Name:       ipmi_delloem_mac_main
+*
+* Description:         This function processes the delloem mac command
+* Input:               intf    - ipmi interface
+                       argc    - no of arguments
+                       argv    - argument string array
+* Output:        
+*
+* Return:              return code     0 - success
+*                         -1 - failure
+*
+******************************************************************/
+
+
+static int ipmi_delloem_mac_main (void * intf, int  argc, char ** argv)
+{
+    int rc = 0;
+
+    current_arg++;
+    if (argc > 1 && strcmp(argv[current_arg], "help") == 0)
+    {
+        ipmi_mac_usage();
+        return 0;
+    }
+    ipmi_idracvalidator_command(intf);
+    if (argc == 1) /*( || (strncmp(argv[current_arg], "list\0", 5) == 0) )*/ 
+    {
+        rc = ipmi_macinfo(intf, 0xff);
+    }
+    else if (strncmp(argv[current_arg], "get\0", 4) == 0)
+    {
+        int currIdInt;
+        current_arg++;
+        if (argv[current_arg] == NULL)
+        {
+            ipmi_mac_usage();
+            return -1;
+        }
+        if(make_int(argv[current_arg],&currIdInt) < 0) {
+            lprintf(LOG_ERR, "Invalid NIC number. The NIC number should be between 0-8\n");
+            return -1;
+        }
+        if( (currIdInt > 8) || (currIdInt < 0) )
+        {
+            lprintf(LOG_ERR, "Invalid NIC number. The NIC number should be between 0-8\n");
+            return -1;
+        }
+        rc = ipmi_macinfo(intf, currIdInt);
+    }
+    else
+    {
+        ipmi_mac_usage();
+    }
+    return(rc);
+}
+
+
+/*****************************************************************
+* Function Name:     make_int
+*
+* Description:   This function convert string into integer
+* Input:         str     - decimal number string
+* Output:        value   - integer value
+* Return:                
+*
+******************************************************************/
+static int make_int(const char *str, int *value)
+{
+    char *tmp=NULL;
+    *value = (int)strtol(str,&tmp,0);
+    if ( tmp-str != strlen(str) )
+    {
+        return -1;
+    }
+    return 0;
+}
+
+
+
+
+
+EmbeddedNICMacAddressType EmbeddedNICMacAddress;
+
+EmbeddedNICMacAddressType_10G EmbeddedNICMacAddress_10G;
+
+static void InitEmbeddedNICMacAddressValues ()
+{
+    uint8_t i;
+    uint8_t j;
+
+
+    for (i=0;i<MAX_LOM;i++)
+    {
+#ifdef LOM_OLD
+        EmbeddedNICMacAddress.LOMMacAddress[i].BladSlotNumber = 0;
+        EmbeddedNICMacAddress.LOMMacAddress[i].MacType = LOM_MACTYPE_RESERVED;
+        EmbeddedNICMacAddress.LOMMacAddress[i].EthernetStatus = LOM_ETHERNET_RESERVED;
+        EmbeddedNICMacAddress.LOMMacAddress[i].NICNumber = 0;
+        EmbeddedNICMacAddress.LOMMacAddress[i].Reserved = 0;
+#else
+	EmbeddedNICMacAddress.LOMMacAddress[i].b0 = 0xF0;
+	EmbeddedNICMacAddress.LOMMacAddress[i].b1 = 0x00;
+#endif
+        for (j=0;j<MACADDRESSLENGH;j++)
+        {
+            EmbeddedNICMacAddress.LOMMacAddress[i].MacAddressByte[j] = 0;
+            EmbeddedNICMacAddress_10G.MacAddress[i].MacAddressByte[j] = 0;
+        }
+    }
+}
+
+uint8_t UseVirtualMacAddress = 0;
+#define VIRTUAL_MAC_OFFSET (2)
+static int ipmi_macinfo_drac_idrac_virtual_mac(void* intf,uint8_t NicNum)
+{
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req;
+
+    uint8_t msg_data[30];
+    uint8_t VirtualMacAddress [MACADDRESSLENGH];
+    uint8_t input_length=0;
+    uint8_t j;
+    //uint8_t length;
+    uint8_t i;
+
+
+    if (0xff==NicNum || IDRAC_NIC_NUMBER==NicNum )
+    {
+        UseVirtualMacAddress = 0;
+
+        input_length = 0;
+        msg_data[input_length++] = 1; /*Get*/
+
+      	req.msg.netfn = IPMI_DELL_OEM_NETFN;
+        req.msg.lun = 0;                
+        req.msg.cmd = GET_IDRAC_VIRTUAL_MAC;
+        req.msg.data = msg_data;
+        req.msg.data_len = input_length;
+
+        rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+	if (rv) { return rv; }
+
+        if( (IMC_IDRAC_12G_MODULAR == IMC_Type) || (IMC_IDRAC_12G_MONOLITHIC== IMC_Type) ) {
+           // Get the Chasiss Assigned MAC Addresss        for 12g Only
+           memcpy(VirtualMacAddress,&rsp[1],MACADDRESSLENGH);
+
+           for (i=0;i<MACADDRESSLENGH;i++)
+           {
+              if (0 != VirtualMacAddress [i])
+              {
+                 UseVirtualMacAddress = 1;
+              }
+           }
+           // Get the Server Assigned MAC Addresss for 12g Only
+           if(!UseVirtualMacAddress) {
+              memcpy(VirtualMacAddress,&rsp[1+MACADDRESSLENGH],MACADDRESSLENGH);
+
+              for (i=0;i<MACADDRESSLENGH;i++)
+              {
+                 if (0 != VirtualMacAddress [i])
+                 {
+                    UseVirtualMacAddress = 1;
+                 }
+              }
+           }
+        } else {
+           memcpy(VirtualMacAddress,&rsp[VIRTUAL_MAC_OFFSET],MACADDRESSLENGH);
+
+           for (i=0;i<MACADDRESSLENGH;i++)
+           {
+              if (0 != VirtualMacAddress [i])
+              {
+                UseVirtualMacAddress = 1;
+              }       
+           }
+	}
+        if (0 == UseVirtualMacAddress)
+            return -1;              
+        if (IMC_IDRAC_10G == IMC_Type)
+            printf ("\nDRAC MAC Address ");
+        else if ( (IMC_IDRAC_11G_MODULAR == IMC_Type) || (IMC_IDRAC_11G_MONOLITHIC== IMC_Type) )
+            printf ("\niDRAC6 MAC Address ");
+        else if ( (IMC_IDRAC_12G_MODULAR == IMC_Type) || (IMC_IDRAC_12G_MONOLITHIC== IMC_Type) )
+            printf ("\niDRAC7 MAC Address ");
+
+        for (j=0;j<5;j++)
+            printf("%02x:",VirtualMacAddress[j]);
+        printf("%02x",VirtualMacAddress[j]); /*5*/
+
+        printf ("\n\r");        
+
+    }  
+    return 0;
+}
+
+
+/*****************************************************************
+* Function Name:    ipmi_macinfo_drac_idrac_mac
+*
+* Description:      This function retrieves the mac address of DRAC or iDRAC
+* Input:            NicNum
+* Output:                 
+* Return:               
+*
+******************************************************************/
+
+static int ipmi_macinfo_drac_idrac_mac(void* intf,uint8_t NicNum)
+{
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req;
+
+    uint8_t msg_data[30];
+    uint8_t input_length=0;
+    uint8_t iDRAC6MacAddressByte[MACADDRESSLENGH];
+    uint8_t j;
+
+    ipmi_macinfo_drac_idrac_virtual_mac (intf,NicNum);
+
+
+    if ((0xff==NicNum || IDRAC_NIC_NUMBER==NicNum) && 0 == UseVirtualMacAddress)
+    {
+
+        input_length = 0;
+
+        msg_data[input_length++] = LAN_CHANNEL_NUMBER; 
+        msg_data[input_length++] = MAC_ADDR_PARAM;  
+        msg_data[input_length++] = 0x00;                        
+        msg_data[input_length++] = 0x00;                        
+
+        req.msg.netfn = TRANSPORT_NETFN;
+        req.msg.lun = 0;                
+        req.msg.cmd = GET_LAN_PARAM_CMD;
+        req.msg.data = msg_data;
+        req.msg.data_len = input_length;
+
+        rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+	if (rv) {
+            printf(" Error in getting MAC Address: ");
+	    if (rv < 0) printf("no response\n");
+	    else printf("Completion Code 0x%02x\n", rv);
+	    return rv;
+        }
+
+        memcpy(iDRAC6MacAddressByte,&rsp[PARAM_REV_OFFSET],MACADDRESSLENGH);
+
+        if (IMC_IDRAC_10G == IMC_Type)
+            printf ("\n\rDRAC MAC Address ");
+		else if ((IMC_IDRAC_11G_MODULAR == IMC_Type) || (IMC_IDRAC_11G_MONOLITHIC== IMC_Type))
+			printf ("\n\riDRAC6 MAC Address ");
+		else if ((IMC_IDRAC_12G_MODULAR == IMC_Type) || (IMC_IDRAC_12G_MONOLITHIC== IMC_Type))		
+			printf ("\n\riDRAC7 MAC Address ");
+        else
+            printf ("\n\riDRAC6 MAC Address ");
+
+        for (j=0;j<5;j++)
+            printf("%02x:",iDRAC6MacAddressByte[j]);
+        printf("%02x",iDRAC6MacAddressByte[j]);
+
+        printf ("\n\r");        
+    }
+    return 0;
+}
+
+
+/*****************************************************************
+* Function Name:    ipmi_macinfo_10g
+*
+* Description:      This function retrieves the mac address of LOMs
+* Input:            intf      - ipmi interface
+                    NicNum    - NIC number
+* Output:               
+* Return:               
+*
+******************************************************************/
+
+static int ipmi_macinfo_10g (void* intf, uint8_t NicNum)
+{
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req;
+
+    uint8_t msg_data[30];
+    uint8_t input_length=0;
+
+    uint8_t j;
+    uint8_t i;
+
+    uint8_t Total_No_NICs = 0;
+
+
+    InitEmbeddedNICMacAddressValues ();
+
+    memset(msg_data, 0, sizeof(msg_data));
+    input_length = 0;
+    msg_data[input_length++] = 0x00; /* Get Parameter Command */
+    msg_data[input_length++] = EMB_NIC_MAC_ADDRESS_9G_10G;  /* OEM Param */
+
+    msg_data[input_length++] = 0x00;         
+    msg_data[input_length++] = 0x00;         
+
+    memset(&req, 0, sizeof(req));
+
+    req.msg.netfn = APP_NETFN;
+    req.msg.lun = 0;                
+    req.msg.cmd = GET_SYSTEM_INFO_CMD;
+    req.msg.data = msg_data;
+
+
+    req.msg.data_len = input_length;
+
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+            printf(" Error in getting MAC Address: ");
+	    if (rv < 0) printf("no response\n");
+	    else printf("Completion Code 0x%02x\n", rv);
+	    return rv;
+    }
+    if (fdebug) dump_buf("GetMacResp_10G",rsp,rsp_len,0);
+
+    Total_No_NICs = (uint8_t) rsp[PARAM_REV_OFFSET]; /* Byte 1: Total Number of Embedded NICs */
+
+    if (IDRAC_NIC_NUMBER != NicNum)
+    {
+        if (0xff == NicNum)
+        {
+            printf ("\n\rSystem LOMs");
+        }       
+        printf("\n\rNIC Number\tMAC Address\n\r");
+
+        memcpy(&EmbeddedNICMacAddress_10G,&rsp[PARAM_REV_OFFSET+TOTAL_N0_NICS_INDEX],Total_No_NICs* MACADDRESSLENGH);
+
+
+        /*Read the LOM type and Mac Addresses */
+
+        for (i=0;i<Total_No_NICs;i++)
+        {
+            if ((0xff==NicNum) || (i == NicNum)     )
+            {       
+                printf ("\n\r%d",i);
+                printf ("\t\t");
+                for (j=0;j<5;j++)
+                {
+                    printf("%02x:",EmbeddedNICMacAddress_10G.MacAddress[i].MacAddressByte[j]);
+                }       
+                printf("%02x",EmbeddedNICMacAddress_10G.MacAddress[i].MacAddressByte[j]);
+            }               
+        }
+        printf ("\n\r");
+
+    }
+
+    ipmi_macinfo_drac_idrac_mac(intf,NicNum);
+
+
+    return 0;
+}
+
+
+/*****************************************************************
+* Function Name:      ipmi_macinfo_11g
+*
+* Description:        This function retrieves the mac address of LOMs
+* Input:              intf - ipmi interface
+* Output:               
+* Return:               
+*
+******************************************************************/
+
+static int ipmi_macinfo_11g (void* intf, uint8_t NicNum)
+{
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req;
+    uint8_t msg_data[30];
+    uint8_t input_length=0;
+    uint8_t len;
+    uint8_t j;
+    uint8_t offset;
+    uint8_t maxlen;
+    uint8_t loop_count;
+    uint8_t i;
+    uint8_t lom_mactype;
+    uint8_t lom_nicnum;
+    uint8_t lom_ethstat;
+    uint8_t *lom_mac;
+    // uint8_t LOMStatus = 0;
+    // uint8_t PlayingDead = 0;
+
+    offset = 0;
+    len = 8; /*eigher 8 or 16 */
+    maxlen = 64;
+    loop_count = maxlen / len;
+
+    InitEmbeddedNICMacAddressValues ();
+
+    memset(msg_data, 0, sizeof(msg_data));
+    input_length = 0;
+    msg_data[input_length++] = 0x00; /* Get Parameter Command */
+    msg_data[input_length++] = EMB_NIC_MAC_ADDRESS_11G;      /* OEM Param */
+
+    msg_data[input_length++] = 0x00;      
+    msg_data[input_length++] = 0x00;      
+    msg_data[input_length++] = 0x00;      
+    msg_data[input_length++] = 0x00;      
+
+    memset(&req, 0, sizeof(req));
+
+    req.msg.netfn = APP_NETFN;
+    req.msg.lun = 0;              
+    req.msg.cmd = GET_SYSTEM_INFO_CMD;
+    req.msg.data = msg_data;
+
+
+    req.msg.data_len = input_length;
+
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+            printf(" Error in getting MAC Address: ");
+	    if (rv < 0) printf("no response\n");
+	    else printf("Completion Code 0x%02x\n", rv);
+	    return rv;
+    }
+
+    len = 8; /*eigher 8 or 16 */
+    maxlen = (uint8_t) rsp[0+PARAM_REV_OFFSET];
+    loop_count = maxlen / len;
+
+    if (IDRAC_NIC_NUMBER != NicNum)
+    {
+        if (0xff == NicNum)
+        {
+            printf ("\n\rSystem LOMs");
+        }       
+        printf("\n\rNIC Number\tMAC Address\t\tStatus\n\r");
+
+
+        /*Read the LOM type and Mac Addresses */
+        offset=0;
+        for (i=0;i<loop_count;i++,offset=offset+len)
+        {
+            input_length = 4;
+            msg_data[input_length++] = offset;
+            msg_data[input_length++] = len;   
+
+            req.msg.netfn = APP_NETFN;
+            req.msg.lun = 0;
+            req.msg.cmd = GET_SYSTEM_INFO_CMD;
+            req.msg.data = msg_data;
+            req.msg.data_len = input_length;
+
+            rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+	    if (rv) {
+		printf(" Error in getting MAC Address: ");
+		if (rv < 0) printf("no response\n");
+		else printf("Completion Code 0x%02x\n", rv);
+		return rv;
+	    }
+	    if (fdebug) {
+		printf("ipmi_macinfo_11g(%d) i=%d offset=%d\n",NicNum,i,offset);
+		dump_buf("GetMacResp",rsp,rsp_len,0);
+	    }
+
+            memcpy(&(EmbeddedNICMacAddress.LOMMacAddress[i]),&rsp[PARAM_REV_OFFSET],len);
+
+#ifdef LOM_OLD
+	    lom_ethstat = EmbeddedNICMacAddress.LOMMacAddress[i].EthernetStatus;
+	    lom_mactype = EmbeddedNICMacAddress.LOMMacAddress[i].MacType;
+	    lom_nicnum  = EmbeddedNICMacAddress.LOMMacAddress[i].NICNumber;
+	    lom_mac     = &EmbeddedNICMacAddress.LOMMacAddress[i].MacAddressByte[0];
+#else
+	    lom_ethstat = ((EmbeddedNICMacAddress.LOMMacAddress[i].b0 & 0xc0) >> 6);
+	    lom_mactype = ((EmbeddedNICMacAddress.LOMMacAddress[i].b0 & 0x30) >> 4);
+	    /* lom_bladslot = (b0 & 0x0f); */
+	    lom_nicnum  = (EmbeddedNICMacAddress.LOMMacAddress[i].b1 & 0x1f);
+	    lom_mac     = &EmbeddedNICMacAddress.LOMMacAddress[i].MacAddressByte[0];
+	    if (fdebug) {
+		printf("\n\rlom_ethstat=%x lom_mactype=%x lom_nicnum=%x\n",
+			lom_ethstat,lom_mactype,lom_nicnum);
+		printf("MacAdrB=%02x:%02x:%02x:%02x:%02x:%02x\n",
+		     lom_mac[0], lom_mac[1], lom_mac[2],
+		     lom_mac[3], lom_mac[4], lom_mac[5]);
+		printf("\n\rrsp_mac=%02x:%02x:%02x:%02x:%02x:%02x\n",
+		     rsp[3], rsp[4], rsp[5], rsp[6], rsp[7], rsp[8]);
+	    }
+	    lom_mac     = &rsp[3];
+#endif
+
+            if (LOM_MACTYPE_ETHERNET == lom_mactype)
+            {
+
+                if (  (0xff==NicNum) || (NicNum == lom_nicnum)  )
+                {
+                    printf ("\n\r%d",lom_nicnum);
+                    printf ("\t\t");
+                    for (j=0;j<5;j++)
+                        printf("%02x:",lom_mac[j]);
+                    printf("%02x",lom_mac[j]);
+
+                    if (LOM_ETHERNET_ENABLED == lom_ethstat)
+                        printf ("\tEnabled");
+                    else
+                        printf ("\tDisabled");
+                }
+            }
+
+        }         
+        printf ("\n\r");
+
+    }
+
+    ipmi_macinfo_drac_idrac_mac(intf,NicNum);
+
+    return 0;
+
+}     
+
+
+
+/*****************************************************************
+* Function Name:      ipmi_macinfo
+*
+* Description:     This function retrieves the mac address of LOMs
+* Input:           intf   - ipmi interface
+* Output:               
+* Return:               
+*
+******************************************************************/
+
+static int ipmi_macinfo (void* intf, uint8_t NicNum)
+{
+    if (IMC_IDRAC_10G == IMC_Type)
+    {
+        return ipmi_macinfo_10g (intf,NicNum);
+    }
+	else if ((IMC_IDRAC_11G_MODULAR == IMC_Type || IMC_IDRAC_11G_MONOLITHIC== IMC_Type )  ||
+			(IMC_IDRAC_12G_MODULAR == IMC_Type || IMC_IDRAC_12G_MONOLITHIC== IMC_Type ) )
+    {
+        return ipmi_macinfo_11g (intf,NicNum);
+    }
+    else
+    {
+        lprintf(LOG_ERR, " Error in getting MAC Address : Not supported platform");
+        return 0;
+    }       
+}
+
+
+/*****************************************************************
+* Function Name:     ipmi_mac_usage
+*
+* Description:   This function prints help message for mac command
+* Input:               
+* Output:       
+*
+* Return:              
+*
+******************************************************************/
+
+static void
+ipmi_mac_usage(void)
+{
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "   mac list");
+    lprintf(LOG_NOTICE, "      Lists the MAC address of LOMs");
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "   mac get <NIC number>");
+    lprintf(LOG_NOTICE, "      Shows the MAC address of specified LOM. 0-7 System LOM, 8- DRAC/iDRAC.");
+    lprintf(LOG_NOTICE, "");
+}
+
+/*****************************************************************
+* Function Name:       ipmi_delloem_lan_main
+*
+* Description:         This function processes the delloem lan command
+* Input:               intf    - ipmi interface
+                       argc    - no of arguments
+                       argv    - argument string array
+* Output:        
+*
+* Return:              return code     0 - success
+*                         -1 - failure
+*
+******************************************************************/
+
+static int ipmi_delloem_lan_main (void * intf, int  argc, char ** argv)
+{
+    int rc = 0;
+
+    int nic_selection = 0;
+    char nic_set[2] = {0};
+    current_arg++;
+    if (argv[current_arg] == NULL || strcmp(argv[current_arg], "help") == 0)
+    {
+        ipmi_lan_usage();
+        return 0;
+    }
+    ipmi_idracvalidator_command(intf);
+    if (!IsLANSupported())
+    {
+        printf("lan is not supported on this system.\n");
+        return -1;
+    }               
+    else if (strncmp(argv[current_arg], "set\0", 4) == 0)
+    {
+        current_arg++;
+        if (argv[current_arg] == NULL)
+        {
+            ipmi_lan_usage();
+            return -1;
+        }
+		if(iDRAC_FLAG == IDRAC_12G) {
+			nic_selection = get_nic_selection_mode_12g(intf,current_arg,argv,nic_set);
+			if (INVALID == nic_selection)
+			{
+				ipmi_lan_usage();
+				return -1;
+                        } else if(INVAILD_FAILOVER_MODE == nic_selection) {
+                                printf(INVAILD_FAILOVER_MODE_STRING);
+                                return 0;
+                        } else if(INVAILD_FAILOVER_MODE_SETTINGS == nic_selection){
+                                printf(INVAILD_FAILOVER_MODE_SET);
+                                return 0;
+                        } else if(INVAILD_SHARED_MODE == nic_selection){
+                                printf(INVAILD_SHARED_MODE_SET_STRING);
+                                return 0;
+			}				
+		
+			rc = ipmi_lan_set_nic_selection_12g(intf,nic_set);
+		}
+		else
+		{
+        	  nic_selection = get_nic_selection_mode(current_arg,argv);
+
+        	  if (INVALID == nic_selection)
+        	  {
+        	    ipmi_lan_usage();
+        	    return -1;
+        	  }
+        	  if(IMC_IDRAC_11G_MODULAR == IMC_Type) {
+        	    printf(INVAILD_SHARED_MODE_SET_STRING);
+        	    return 0;
+        	  }
+        	  rc = ipmi_lan_set_nic_selection(intf,nic_selection);
+		}		
+        return 0;                       
+    }
+    else if (strncmp(argv[current_arg], "get\0", 4) == 0)
+    {
+        current_arg++;
+        if (argv[current_arg] == NULL)
+        {
+            rc = ipmi_lan_get_nic_selection(intf);
+            return rc;
+        }
+        else if (strncmp(argv[current_arg], "active\0", 7) == 0)                
+        {
+            rc = ipmi_lan_get_active_nic(intf);
+            return rc;
+        }
+        else
+        {
+            ipmi_lan_usage();
+        }
+
+    }
+    else
+    {
+        ipmi_lan_usage();
+        return -1;
+    }
+    return(rc);
+}
+
+
+static int IsLANSupported ()
+{
+    if (IMC_IDRAC_11G_MODULAR == IMC_Type)
+        return 0;
+    return 1;
+}
+
+
+int get_nic_selection_mode_12g (void* intf,int current_arg, char ** argv, char *nic_set)
+{
+	int failover = 0;
+
+	// First get the current settings.
+	uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+	struct ipmi_rq req;
+
+	uint8_t msg_data[30];
+	uint8_t input_length=0;
+	
+	input_length = 0;
+		
+   	req.msg.netfn = IPMI_DELL_OEM_NETFN;
+   	req.msg.lun = 0;		
+	
+  	req.msg.cmd = GET_NIC_SELECTION_12G_CMD;
+
+  	req.msg.data = msg_data;
+  	req.msg.data_len = input_length;
+  
+	rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+	if (rv) {
+            printf(" Error in getting NIC selection: ");
+	    if (rv < 0) printf("no response\n");
+	    else printf("Completion Code 0x%02x %s\n",
+				rv,decode_cc(0,rv));
+	    return rv;
+	}
+	
+	nic_set[0] = rsp[0];
+	nic_set[1] = rsp[1];
+
+	
+	if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "dedicated\0", 10)) 
+	{
+		nic_set[0] = 1;
+		nic_set[1] = 0;
+		return 0;
+	}
+	if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "shared\0", 7)) 
+	{
+		
+	}
+	else
+		return INVALID;
+	
+	current_arg++;	
+	if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "with\0", 5)) 
+	{
+	}	
+	else
+		return INVALID;		
+	
+	current_arg++;	
+	if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "failover\0", 9)) 
+	{
+		failover = 1;
+	}	
+	if(failover)
+		current_arg++;	
+	if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "lom1\0", 5)) 
+	{
+                if(IMC_IDRAC_12G_MODULAR == IMC_Type)
+                {
+                        return INVAILD_SHARED_MODE;
+                }
+		if(failover) {
+                        if(nic_set[0] == 2)
+                        {
+                                return INVAILD_FAILOVER_MODE;
+                        } else if(nic_set[0] == 1) {
+                                return INVAILD_FAILOVER_MODE_SETTINGS;
+                        }
+			nic_set[1] = 2;
+		}	
+		else {
+			nic_set[0] = 2;
+                        if(nic_set[1] == 2)
+                                nic_set[1] = 0;
+		}	
+		return 0;
+	}
+	else if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "lom2\0", 5)) 
+	{
+                if(IMC_IDRAC_12G_MODULAR == IMC_Type)
+                {
+                        return INVAILD_SHARED_MODE;
+                }
+		if(failover) {		
+			if(nic_set[0] == 3)
+                        {
+                                return INVAILD_FAILOVER_MODE;
+                        } else if(nic_set[0] == 1) {
+                                return INVAILD_FAILOVER_MODE_SETTINGS;
+                        }
+			nic_set[1] = 3;
+		}	
+		else {
+			nic_set[0] = 3;
+			if(nic_set[1] == 3)
+			        nic_set[1] = 0;
+
+		}	
+		return 0;
+	}
+	else if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "lom3\0", 5)) 
+	{
+                if(IMC_IDRAC_12G_MODULAR == IMC_Type)
+                {
+                        return INVAILD_SHARED_MODE;
+                }
+		if(failover) {	
+                        if(nic_set[0] == 4)
+                        {
+                                return INVAILD_FAILOVER_MODE;
+                        } else if(nic_set[0] == 1) {
+                                return INVAILD_FAILOVER_MODE_SETTINGS;
+                        }
+			nic_set[1] = 4;
+		}	
+		else {
+			nic_set[0] = 4;
+                        if(nic_set[1] == 4)
+                                nic_set[1] = 0;
+ 	}	
+		return 0;
+	} 
+	else if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "lom4\0", 5)) 
+	{
+                if(IMC_IDRAC_12G_MODULAR == IMC_Type)
+                {
+                        return INVAILD_SHARED_MODE;
+                }
+		if(failover) {	
+                        if(nic_set[0] == 5)
+                        {
+                                return INVAILD_FAILOVER_MODE;
+                        } else if(nic_set[0] == 1) {
+                                return INVAILD_FAILOVER_MODE_SETTINGS;
+                        }
+			nic_set[1] = 5;
+		}	
+		else {
+			nic_set[0] = 5;
+                        if(nic_set[1] == 5)
+                                nic_set[1] = 0;
+		}	
+		return 0;
+	}	
+	else if (failover && NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "none\0", 5)) 
+	{
+		if(IMC_IDRAC_12G_MODULAR == IMC_Type)
+		{
+		        return INVAILD_SHARED_MODE;
+		}
+		if(failover) {
+			if(nic_set[0] == 1) {
+				return INVAILD_FAILOVER_MODE_SETTINGS;
+			}
+			nic_set[1] = 0;
+		}	
+		return 0;
+	}	
+	else if (failover && NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "all\0", 4)) 
+	{
+	}	
+	else
+		return INVALID;	
+	
+	current_arg++;	
+	if (failover && NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "loms\0", 5)) 
+	{
+		if(IMC_IDRAC_12G_MODULAR == IMC_Type)
+		{
+			return INVAILD_SHARED_MODE;
+		}
+		if(nic_set[0] == 1) {
+			return INVAILD_FAILOVER_MODE_SETTINGS;
+		}
+		nic_set[1] = 6;
+		return 0;
+	}	
+
+	return INVALID;
+	
+}
+
+
+static int get_nic_selection_mode (int current_arg, char ** argv)
+{
+    if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "dedicated\0", 10)) 
+    {
+        return DEDICATED;
+    }
+    if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "shared\0", 7)) 
+    {
+        if (NULL == argv[current_arg+1] )
+            return SHARED;          
+    }
+    current_arg++;  
+    if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "with\0", 5)) 
+    {
+    }       
+    else
+        return INVALID;         
+
+    current_arg++;  
+    if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "failover\0", 9)) 
+    {
+    }       
+    else
+        return INVALID;         
+
+    current_arg++;  
+    if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "lom2\0", 5)) 
+    {
+        return SHARED_WITH_FAILOVER_LOM2;
+    }       
+    else if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "all\0", 4)) 
+    {
+    }       
+    else
+        return INVALID; 
+
+    current_arg++;  
+    if (NULL!= argv[current_arg] && 0 == strncmp(argv[current_arg], "loms\0", 5)) 
+    {
+        return SHARED_WITH_FAILOVER_ALL_LOMS;
+    }       
+
+    return INVALID;
+	
+}
+
+
+static int ipmi_lan_set_nic_selection_12g (void* intf, uint8_t* nic_selection)
+{
+	uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+	struct ipmi_rq req;
+
+	uint8_t msg_data[30];
+	uint8_t input_length=0;
+
+	input_length = 0;
+		
+	msg_data[input_length++] = nic_selection[0]; 
+	msg_data[input_length++] = nic_selection[1]; 
+
+	req.msg.netfn = IPMI_DELL_OEM_NETFN;
+	req.msg.lun = 0;		
+	req.msg.cmd = SET_NIC_SELECTION_12G_CMD;
+	req.msg.data = msg_data;
+	req.msg.data_len = input_length;
+  
+	rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+	if (rv) {
+            printf(" Error in setting NIC selection: ");
+	    if (rv < 0) printf("no response\n");
+	    else printf("Completion Code 0x%02x %s\n",
+				rv,decode_cc(0,rv));
+	    return rv;
+	}
+	printf("configured successfully");
+
+	return 0;
+}
+
+
+static int ipmi_lan_set_nic_selection (void* intf, uint8_t nic_selection)
+{
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req;
+
+    uint8_t msg_data[30];
+    uint8_t input_length=0;
+    //uint8_t j;
+
+    input_length = 0;
+
+    msg_data[input_length++] = nic_selection; 
+
+   	req.msg.netfn = IPMI_DELL_OEM_NETFN;
+    req.msg.lun = 0;                
+    req.msg.cmd = SET_NIC_SELECTION_CMD;
+    req.msg.data = msg_data;
+    req.msg.data_len = input_length;
+
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+            printf(" Error in setting NIC selection: ");
+	    if (rv < 0) printf("no response\n");
+	    else printf("Completion Code 0x%02x %s\n",
+				rv,decode_cc(0,rv));
+	    return rv;
+    }
+    printf("configured successfully");
+
+    return 0;
+}      
+
+static int ipmi_lan_get_nic_selection (void* intf)
+{
+    uint8_t nic_selection=-1;
+	uint8_t nic_selection_failover = 0;
+
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req;
+
+    uint8_t msg_data[30];
+    uint8_t input_length=0;
+    //uint8_t j;
+
+    input_length = 0;
+
+    req.msg.netfn = IPMI_DELL_OEM_NETFN;
+    req.msg.lun = 0;                
+    if(iDRAC_FLAG == IDRAC_12G)
+  	req.msg.cmd = GET_NIC_SELECTION_12G_CMD;
+    else  	
+        req.msg.cmd = GET_NIC_SELECTION_CMD;
+    req.msg.data = msg_data;
+    req.msg.data_len = input_length;
+
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+            printf(" Error in getting NIC selection: ");
+	    if (rv < 0) printf("no response\n");
+	    else printf("Completion Code 0x%02x %s\n",
+				rv,decode_cc(0,rv));
+	    return rv;
+    }
+    nic_selection = rsp[0];
+
+	if(iDRAC_FLAG == IDRAC_12G)
+	{		
+		
+		nic_selection_failover = rsp[1];
+		if ((nic_selection < 6) && (nic_selection > 0) && (nic_selection_failover < 7))
+		{
+			if(nic_selection == 1) {
+				printf ("%s\n",NIC_Selection_Mode_String_12g[nic_selection-1]);
+			} else if(nic_selection) {
+				printf ("Shared LOM   :  %s\n",NIC_Selection_Mode_String_12g[nic_selection-1]);
+				if(nic_selection_failover  == 0)
+					printf ("Failover LOM :  None\n");
+				else if(nic_selection_failover   >= 2 && nic_selection_failover   <= 6)
+					printf ("Failover LOM :  %s\n",NIC_Selection_Mode_String_12g[nic_selection_failover + 3]);
+			}
+				
+		} 
+		else
+		{
+			lprintf(LOG_ERR, " Error Outof bond Value received (%d) (%d) \n",nic_selection,nic_selection_failover);
+		  	return -1;	  	
+		}
+	}
+	else
+	{
+		printf ("%s\n",NIC_Selection_Mode_String[nic_selection]);
+	}
+
+    return 0;
+}      
+
+static int ipmi_lan_get_active_nic (void* intf)
+{
+    uint8_t active_nic=0;
+    uint8_t current_lom =0;
+
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req;
+
+    uint8_t msg_data[30];
+    uint8_t input_length=0;
+
+    input_length = 0;
+
+    msg_data[input_length++] = 0; /*Get current LOM*/
+    msg_data[input_length++] = 0; /*Reserved*/
+    msg_data[input_length++] = 0; /*Reserved*/        
+
+    req.msg.netfn = IPMI_DELL_OEM_NETFN;
+    req.msg.lun = 0;                
+    req.msg.cmd = GET_ACTIVE_NIC_CMD;
+    req.msg.data = msg_data;
+    req.msg.data_len = input_length;
+
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+            printf(" Error in getting Current LOM: ");
+	    if (rv < 0) printf("no response\n");
+	    else printf("Completion Code 0x%02x %s\n",
+				rv,decode_cc(0,rv));
+	    return rv;
+    }
+    current_lom = rsp[0];
+
+    input_length = 0;
+
+    msg_data[input_length++] = 1; //Get Link status
+    msg_data[input_length++] = 0; //Reserved
+    msg_data[input_length++] = 0; //Reserved
+
+    req.msg.netfn = IPMI_DELL_OEM_NETFN;
+    req.msg.lun = 0;
+    req.msg.cmd = GET_ACTIVE_NIC_CMD;
+    req.msg.data = msg_data;
+    req.msg.data_len = input_length;
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+            printf(" Error in getting Active LOM Status: ");
+	    if (rv < 0) printf("no response\n");
+	    else printf("Completion Code 0x%02x %s\n",
+				rv,decode_cc(0,rv));
+	    return rv;
+    }
+
+    active_nic = rsp[1];
+    if (current_lom < 5 && active_nic)
+        printf ("\n%s\n",ActiveLOM_String[current_lom]);
+    else
+        printf ("\n%s\n",ActiveLOM_String[5]);
+
+    return 0;
+}
+
+
+static void
+ipmi_lan_usage(void)
+{
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "   lan set <Mode> ");
+    lprintf(LOG_NOTICE, "      sets the NIC Selection Mode :");
+    lprintf(LOG_NOTICE, "          on iDRAC12g :");
+
+    lprintf(LOG_NOTICE, "              dedicated, shared with lom1, shared with lom2,shared with lom3,shared ");
+    lprintf(LOG_NOTICE, "              with lom4,shared with failover lom1,shared with failover lom2,shared ");
+    lprintf(LOG_NOTICE, "              with failover lom3,shared with failoverlom4,shared with Failover all ");
+    lprintf(LOG_NOTICE, "              loms, shared with Failover None).");
+    lprintf(LOG_NOTICE, "          on other systems :");
+    lprintf(LOG_NOTICE, "              dedicated, shared, shared with failoverlom2,");
+    lprintf(LOG_NOTICE, "              shared with Failover all loms.");
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "   lan get ");
+    lprintf(LOG_NOTICE, "          on iDRAC12g :");
+    lprintf(LOG_NOTICE, "              returns the current NIC Selection Mode (dedicated, shared with lom1, shared ");
+    lprintf(LOG_NOTICE, "              with lom2, shared with lom3, shared with lom4,shared with failover lom1,");
+    lprintf(LOG_NOTICE, "              shared with failover lom2,shared with failover lom3,shared with failover ");
+    lprintf(LOG_NOTICE, "              lom4,shared with Failover all loms,shared with Failover None).");
+    lprintf(LOG_NOTICE, "          on other systems :");
+    lprintf(LOG_NOTICE, "              dedicated, shared, shared with failover,");
+    lprintf(LOG_NOTICE, "              lom2, shared with Failover all loms.");
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "   lan get active");
+    lprintf(LOG_NOTICE, "      Get the current active LOMs (LOM1, LOM2, LOM3, LOM4, NONE).");
+    lprintf(LOG_NOTICE, "");
+
+}
+
+/*****************************************************************
+* Function Name:       ipmi_delloem_powermonitor_main
+*
+* Description:         This function processes the delloem powermonitor command
+* Input:               intf    - ipmi interface
+                       argc    - no of arguments
+                       argv    - argument string array
+* Output:        
+*
+* Return:              return code     0 - success
+*                         -1 - failure
+*
+******************************************************************/
+
+static int ipmi_delloem_powermonitor_main (void * intf, int  argc, char ** argv)
+{
+    int rc = 0;
+
+    current_arg++;
+    if (argc > 1 && strcmp(argv[current_arg], "help") == 0)
+    {
+        ipmi_powermonitor_usage();
+        return 0;
+    }
+    ipmi_idracvalidator_command(intf);
+    if (argc == 1)
+    {
+        rc = ipmi_powermgmt(intf);
+    }
+    else if (strncmp(argv[current_arg], "status\0", 7) == 0) 
+    {
+        rc = ipmi_powermgmt(intf);
+    }
+
+    else if (strncmp(argv[current_arg], "clear\0", 6) == 0) 
+    {
+        current_arg++;
+        if (argv[current_arg] == NULL) 
+        {
+            ipmi_powermonitor_usage();
+            return -1;
+        }
+        else if (strncmp(argv[current_arg], "peakpower\0", 10) == 0) 
+        {
+            rc = ipmi_powermgmt_clear(intf, 1);
+        }
+        else if (strncmp(argv[current_arg], "cumulativepower\0", 16) == 0) 
+        {
+            rc = ipmi_powermgmt_clear(intf, 0);
+        }
+        else 
+        {
+            ipmi_powermonitor_usage();
+            return -1;
+        }
+
+    }
+
+
+    else if (strncmp(argv[current_arg], "powerconsumption\0", 17) == 0) 
+    {
+        current_arg++;
+
+        if (argv[current_arg] == NULL)
+        {
+
+            rc=ipmi_print_get_power_consmpt_data(intf,watt);
+
+        }
+        else if (strncmp(argv[current_arg], "watt\0", 5) == 0) 
+        {
+
+            rc = ipmi_print_get_power_consmpt_data(intf, watt);
+        }
+        else if (strncmp(argv[current_arg], "btuphr\0", 7) == 0) 
+        {
+            rc = ipmi_print_get_power_consmpt_data(intf, btuphr);
+        }
+        else
+        {
+            ipmi_powermonitor_usage();
+            return -1;
+        }
+    }
+    else if (strncmp(argv[current_arg], "powerconsumptionhistory\0", 23) == 0) 
+    {
+        current_arg++;
+        if (argv[current_arg] == NULL)
+        {
+            rc=ipmi_print_power_consmpt_history(intf,watt);
+
+        }
+        else if (strncmp(argv[current_arg], "watt\0", 5) == 0) 
+        {
+            rc = ipmi_print_power_consmpt_history(intf, watt);
+        }
+        else if (strncmp(argv[current_arg], "btuphr\0", 7) == 0)
+        {
+            rc = ipmi_print_power_consmpt_history(intf, btuphr);
+        }
+        else
+        {
+            ipmi_powermonitor_usage();
+            return -1;
+        }
+
+    }
+
+    else if (strncmp(argv[current_arg], "getpowerbudget\0", 15) == 0)
+    {
+        current_arg++;
+        if (argv[current_arg] == NULL)
+        {
+            rc=ipmi_print_power_cap(intf,watt);
+
+        }
+        else if (strncmp(argv[current_arg], "watt\0", 5) == 0)
+        {
+            rc = ipmi_print_power_cap(intf, watt);
+        }
+        else if (strncmp(argv[current_arg], "btuphr\0", 7) == 0)
+        {
+            rc = ipmi_print_power_cap(intf, btuphr);
+        }
+        else
+        {
+            ipmi_powermonitor_usage();
+            return -1;
+        }
+
+    }
+
+    else if (strncmp(argv[current_arg], "setpowerbudget\0", 15) == 0)
+    {
+        int val;
+        current_arg++;
+        if (argv[current_arg] == NULL)
+        { 
+            ipmi_powermonitor_usage();
+            return -1;
+        }
+		if (strchr(argv[current_arg], '.'))
+		{
+			lprintf(LOG_ERR, " Cap value in Watts, Btu/hr or percent should be whole number");
+			return -1;
+		}
+        make_int(argv[current_arg],&val);
+        current_arg++;
+        if (argv[current_arg] == NULL)
+        {       
+            ipmi_powermonitor_usage();
+        }
+        else if (strncmp(argv[current_arg], "watt\0", 5) == 0)
+        {
+            rc=ipmi_set_power_cap(intf,watt,val);
+        }
+        else if (strncmp(argv[current_arg], "btuphr\0", 7) == 0)
+        {
+            rc=ipmi_set_power_cap(intf, btuphr,val);
+        }
+        else if (strncmp(argv[current_arg], "percent\0", 8) == 0)
+        {
+            rc=ipmi_set_power_cap(intf,percent,val);
+        }
+        else
+        {
+            ipmi_powermonitor_usage();
+            return -1;
+        }
+
+    }
+
+    else if (strncmp(argv[current_arg], "enablepowercap\0", 15) == 0)
+    {
+        rc = ipmi_set_power_capstatus_command(intf,1);
+    }
+
+    else if (strncmp(argv[current_arg], "disablepowercap\0", 16) == 0)
+    {
+        rc = ipmi_set_power_capstatus_command(intf,0);
+    }
+    else
+    {
+        ipmi_powermonitor_usage();
+        return -1;
+    }
+    if (sdrcache != NULL) free_sdr_cache(sdrcache); 
+    return(rc);
+}
+
+
+/*****************************************************************
+* Function Name:     ipmi_time_to_str
+*
+* Description:       This function converts ipmi time format into gmtime format
+* Input:             rawTime  - ipmi time format 
+* Output:            strTime  - gmtime format
+*
+* Return:              
+*
+******************************************************************/
+
+static void
+ipmi_time_to_str(time_t rawTime, char* strTime)
+{
+    struct tm * tm;
+    char *temp;
+    tm = gmtime(&rawTime);
+
+    temp = asctime(tm);
+
+    strcpy(strTime,temp);
+}
+
+#ifdef NOT_USED
+static int ipmi_get_sensor_reading(void *intf ,
+            unsigned char sensorNumber, 
+                        SensorReadingType* pSensorReadingData);
+/*****************************************************************
+* Function Name:      ipmi_get_sensor_reading
+*
+* Description:        This function retrieves a raw sensor reading
+* Input:              sensorOwner       - sensor owner id
+*                     sensorNumber      - sensor id
+*                     intf              - ipmi interface
+* Output:             sensorReadingData - ipmi response structure
+* Return:             1 on error
+*                     0 if successful
+*
+******************************************************************/
+static int
+ipmi_get_sensor_reading(void *intf ,
+                unsigned char sensorNumber,
+                        SensorReadingType* pSensorReadingData)
+{
+    struct ipmi_rq req;
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len;
+    int rc = 0;
+    // uint8_t save_addr;
+
+    memset(&req, 0, sizeof (req));
+    req.msg.netfn = IPMI_NETFN_SE;
+    req.msg.lun = 0;
+    req.msg.cmd = (uint8_t)(GET_SENSOR_READING | 0x0ff);
+    req.msg.data = &sensorNumber;
+    req.msg.data_len = 1;
+
+    if (NULL == pSensorReadingData)
+        return -1;
+    memset(pSensorReadingData,0, sizeof(SensorReadingType));        
+
+    rc = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rc) return 1; 
+
+    memcpy(pSensorReadingData, rsp, sizeof(SensorReadingType));
+
+    /* if sensor messages are disabled, return error*/
+    if ((!(rsp[1]& 0xC0)) || ((rsp[1] & 0x20))) {
+        rc =1;
+    }
+    return rc;
+}
+#endif
+
+
+/*****************************************************************
+* Function Name:   ipmi_get_power_capstatus_command
+*
+* Description:     This function gets the power cap status
+* Input:           intf                 - ipmi interface
+* Global:          PowercapSetable_flag - power cap status
+* Output:                
+*
+* Return:              
+*
+******************************************************************/
+static int
+ipmi_get_power_capstatus_command (void * intf)
+{
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req = {0};
+    uint8_t data[2];
+
+    req.msg.netfn = IPMI_DELL_OEM_NETFN;
+    req.msg.lun = 0;
+    req.msg.cmd = IPMI_DELL_POWER_CAP_STATUS;
+    req.msg.data_len = 2;
+    req.msg.data = data;
+    data[0] = 01;
+    data[1] = 0xFF;
+
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+            printf(" Error getting powercap status: ");
+	    if (rv < 0) printf("no response\n");
+	    else printf("Completion Code 0x%02x %s\n",
+				rv,decode_cc(0,rv));
+	    return rv;
+    }
+    if (rsp[0]&0x02)
+        PowercapSetable_flag=1;
+    if(rsp[0]&0x01)
+        PowercapstatusFlag=1;
+    return 0;
+}
+
+/*****************************************************************
+* Function Name:    ipmi_set_power_capstatus_command
+*
+* Description:      This function sets the power cap status
+* Input:            intf     - ipmi interface
+*                   val      - power cap status
+* Output:            
+*
+* Return:              
+*
+******************************************************************/
+
+static int
+ipmi_set_power_capstatus_command (void * intf,uint8_t val)
+{
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req = {0};
+    uint8_t data[2];
+	if(ipmi_get_power_capstatus_command(intf) < 0)
+		return -1;
+
+    if (PowercapSetable_flag!=1)
+    {
+        lprintf(LOG_ERR, " Can not set powercap on this system");
+        return -1;
+    }
+    req.msg.netfn = IPMI_DELL_OEM_NETFN;
+    req.msg.lun = 0;
+    req.msg.cmd = IPMI_DELL_POWER_CAP_STATUS;
+    req.msg.data_len = 2;
+    req.msg.data = data;
+
+    data[0] = 00;
+    data[1] = val;
+
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+         printf(" Error setting powercap status: ");
+	 if (rv < 0) printf("no response\n");
+	 else if((iDRAC_FLAG == IDRAC_12G) && (rv == LICENSE_NOT_SUPPORTED)) {
+		printf("FM001 : A required license is missing or expired\n");
+		return rv;	//return unlicensed Error code
+	 } 
+	 else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+	 return rv;
+    }
+
+    return 0;
+}
+
+
+
+/*****************************************************************
+* Function Name:    ipmi_powermgmt
+*
+* Description:      This function print the powermonitor details
+* Input:            intf     - ipmi interface
+* Output:              
+*
+* Return:              
+*
+******************************************************************/
+static int ipmi_powermgmt(void* intf)
+{
+    time_t now;
+    struct tm* tm;
+    char* dte;
+
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req;
+    uint8_t msg_data[2];
+    uint32_t cumStartTimeConv;
+    uint32_t cumReadingConv;
+    uint32_t maxPeakStartTimeConv;
+    uint32_t ampPeakTimeConv;
+    uint16_t ampReadingConv;
+    uint32_t wattPeakTimeConv;
+    uint32_t wattReadingConv;
+    uint32_t bmctimeconv;
+    uint32_t * bmctimeconvval;
+
+    IPMI_POWER_MONITOR* pwrMonitorInfo;
+
+
+    char cumStartTime[26];
+    char maxPeakStartTime[26];
+    char ampPeakTime[26];
+    char wattPeakTime[26];
+    char bmctime[26];
+
+    // float cumReading;
+    int ampReading;
+    int wattReading;
+    int ampReadingRemainder;
+    // int round;
+    // int round2;
+    int remainder;
+
+    now = time(0);
+    tm = gmtime(&now);
+    dte = asctime(tm);
+
+    memset(&req, 0, sizeof(req));
+    req.msg.netfn = IPMI_NETFN_STORAGE;
+    req.msg.lun = 0;
+    req.msg.cmd = IPMI_CMD_GET_SEL_TIME;
+
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+        printf(" Error getting BMC time info ");
+	if (rv < 0) printf("no response\n");
+	else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+	return rv;
+    }
+    bmctimeconvval=(uint32_t*)rsp;
+#if WORDS_BIGENDIAN
+    bmctimeconv=BSWAP_32(*bmctimeconvval);
+#else
+    bmctimeconv=*bmctimeconvval;
+#endif
+
+    /* get powermanagement info*/
+    req.msg.netfn = IPMI_DELL_OEM_NETFN;
+    req.msg.lun = 0x0;
+    req.msg.cmd = GET_PWRMGMT_INFO_CMD;
+    req.msg.data = msg_data;
+    req.msg.data_len = 2;
+
+    memset(msg_data, 0, 2);
+    msg_data[0] = 0x07;     
+    msg_data[1] = 0x01;
+
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+	printf(" Error getting power management info ");
+	if (rv < 0) printf("no response\n");
+	else if((iDRAC_FLAG == IDRAC_12G) && (rv == LICENSE_NOT_SUPPORTED)) {
+		printf("FM001 : A required license is missing or expired\n");
+		return rv;	
+	} 
+	else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+	return rv;
+    }
+
+    pwrMonitorInfo = (IPMI_POWER_MONITOR*)rsp;
+
+#if WORDS_BIGENDIAN
+    cumStartTimeConv = BSWAP_32(pwrMonitorInfo->cumStartTime);
+    cumReadingConv = BSWAP_32(pwrMonitorInfo->cumReading);
+    maxPeakStartTimeConv = BSWAP_32(pwrMonitorInfo->maxPeakStartTime);
+    ampPeakTimeConv = BSWAP_32(pwrMonitorInfo->ampPeakTime);
+    ampReadingConv = BSWAP_16(pwrMonitorInfo->ampReading);
+    wattPeakTimeConv = BSWAP_32(pwrMonitorInfo->wattPeakTime);
+    wattReadingConv = BSWAP_16(pwrMonitorInfo->wattReading);
+#else
+    cumStartTimeConv = pwrMonitorInfo->cumStartTime;
+    cumReadingConv = pwrMonitorInfo->cumReading;
+    maxPeakStartTimeConv = pwrMonitorInfo->maxPeakStartTime;
+    ampPeakTimeConv = pwrMonitorInfo->ampPeakTime;
+    ampReadingConv = pwrMonitorInfo->ampReading;
+    wattPeakTimeConv = pwrMonitorInfo->wattPeakTime;
+    wattReadingConv = pwrMonitorInfo->wattReading;
+#endif
+
+    ipmi_time_to_str(cumStartTimeConv, cumStartTime);
+
+    ipmi_time_to_str(maxPeakStartTimeConv, maxPeakStartTime);
+    ipmi_time_to_str(ampPeakTimeConv, ampPeakTime);
+    ipmi_time_to_str(wattPeakTimeConv, wattPeakTime);
+    ipmi_time_to_str(bmctimeconv, bmctime);
+
+    now = time(0);
+
+
+    remainder = (cumReadingConv % 1000);
+    cumReadingConv = cumReadingConv / 1000;
+    remainder = (remainder + 50) / 100;
+
+    ampReading = ampReadingConv;
+    ampReadingRemainder = ampReading%10;
+    ampReading = ampReading/10;
+
+    wattReading = wattReadingConv;
+
+    printf("Power Tracking Statistics\n");
+    printf("Statistic      : Cumulative Energy Consumption\n");
+    printf("Start Time     : %s", cumStartTime);
+    printf("Finish Time    : %s", bmctime);
+    printf("Reading        : %d.%d kWh\n\n", cumReadingConv, remainder);
+
+    printf("Statistic      : System Peak Power\n");
+    printf("Start Time     : %s", maxPeakStartTime);
+    printf("Peak Time      : %s", wattPeakTime);
+    printf("Peak Reading   : %d W\n\n", wattReading);
+
+    printf("Statistic      : System Peak Amperage\n");
+    printf("Start Time     : %s", maxPeakStartTime);
+    printf("Peak Time      : %s", ampPeakTime);
+    printf("Peak Reading   : %d.%d A\n", ampReading, ampReadingRemainder);
+
+
+    return 0;
+
+}
+/*****************************************************************
+* Function Name:    ipmi_powermgmt_clear
+*
+* Description:     This function clears peakpower / cumulativepower value
+* Input:           intf           - ipmi interface
+*                  clearValue     - peakpower / cumulativepower
+* Output:          
+*
+* Return:              
+*
+******************************************************************/
+static int
+ipmi_powermgmt_clear(void* intf,uint8_t clearValue)
+{
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req;
+    uint8_t clearType;
+    uint8_t msg_data[3];
+
+    if (clearValue) {
+        clearType = 2;
+    } else {
+        clearType = 1;
+    }
+
+    /* clear powermanagement info*/
+    req.msg.netfn = IPMI_DELL_OEM_NETFN;
+    req.msg.lun = 0;
+    req.msg.cmd = CLEAR_PWRMGMT_INFO_CMD;
+    req.msg.data = msg_data;
+    req.msg.data_len = 3;
+
+
+    memset(msg_data, 0, 3);
+    msg_data[0] = 0x07;
+    msg_data[1] = 0x01;
+    msg_data[2] = clearType;
+
+
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+	printf(" Error clearing power values: ");
+	if (rv < 0) printf("no response\n");
+	else if((iDRAC_FLAG == IDRAC_12G) && (rv == LICENSE_NOT_SUPPORTED)) {
+		printf("FM001 : A required license is missing or expired\n");
+		return rv;	
+	} 
+	else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+	return rv;
+    }
+	return 0;
+
+}
+
+/*****************************************************************
+* Function Name:    watt_to_btuphr_conversion
+*
+* Description:      This function converts the power value in watt to btuphr
+* Input:            powerinwatt     - power in watt
+*                               
+* Output:           power in btuphr
+*
+* Return:              
+*
+******************************************************************/
+static uint64_t watt_to_btuphr_conversion(uint32_t powerinwatt)
+{
+    uint64_t powerinbtuphr;
+    powerinbtuphr=(uint64_t)(3.413*powerinwatt);
+
+    return(powerinbtuphr);
+}
+
+/*****************************************************************
+* Function Name:    btuphr_to_watt_conversion
+*
+* Description:      This function converts the power value in  btuphr to watt
+* Input:            powerinbtuphr   - power in btuphr
+*                              
+* Output:           power in watt
+*
+* Return:                
+*
+******************************************************************/
+static uint32_t btuphr_to_watt_conversion(uint64_t powerinbtuphr)
+{
+    uint32_t powerinwatt;
+    /*returning the floor value*/
+    powerinwatt= (uint32_t)(powerinbtuphr/3.413);
+    return (powerinwatt);
+}
+
+/*****************************************************************
+* Function Name:        ipmi_get_power_headroom_command
+*
+* Description:          This function prints the Power consumption information
+* Input:                intf    - ipmi interface
+*                       unit    - watt / btuphr
+* Output:           
+*
+* Return:              
+*
+******************************************************************/
+static int ipmi_get_power_headroom_command (void * intf,uint8_t unit)
+{
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req = {0};
+    uint64_t peakpowerheadroombtuphr;
+    uint64_t instantpowerhearoom;
+
+    req.msg.netfn = IPMI_DELL_OEM_NETFN;
+    req.msg.lun = 0;
+    req.msg.cmd = GET_PWR_HEADROOM_CMD;
+    req.msg.data_len = 0;
+
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+	printf(" Error getting power headroom status: ");
+	if (rv < 0) printf("no response\n");
+	else if((iDRAC_FLAG == IDRAC_12G) && (rv == LICENSE_NOT_SUPPORTED)) {
+		printf("FM001 : A required license is missing or expired\n");
+		return rv;	
+	}
+	else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+	return rv;
+    }
+    if(verbose>1)
+        printf("power headroom  Data               : %x %x %x %x ",
+        /*need to look into */                                                                  rsp[0], rsp[1], rsp[2], rsp[3]);
+    powerheadroom= *(( POWER_HEADROOM *)rsp);
+#if WORDS_BIGENDIAN
+    powerheadroom.instheadroom = BSWAP_16(powerheadroom.instheadroom);
+    powerheadroom.peakheadroom = BSWAP_16(powerheadroom.peakheadroom);
+#endif
+
+    printf ("Headroom\n\r");
+    printf ("Statistic                     Reading\n\r");   
+
+    if(unit == btuphr)
+    {
+        peakpowerheadroombtuphr=watt_to_btuphr_conversion(powerheadroom.peakheadroom);
+        instantpowerhearoom= watt_to_btuphr_conversion(powerheadroom.instheadroom);
+
+        printf ("System Instantaneous Headroom : %ld BTU/hr\n",instantpowerhearoom);
+		printf ("System Peak Headroom          : %ld BTU/hr\n",peakpowerheadroombtuphr);
+	}
+	else
+	{
+        printf ("System Instantaneous Headroom : %ld W\n",powerheadroom.instheadroom);
+		printf ("System Peak Headroom          : %ld W\n",powerheadroom.peakheadroom);
+	}
+
+    return 0;
+}
+
+/*****************************************************************
+* Function Name:       ipmi_get_power_consumption_data
+*
+* Description:         This function updates the instant Power consumption information
+* Input:               intf - ipmi interface
+* Output:              power consumption current reading 
+*                      Assumption value will be in Watt.
+*
+* Return:               
+*
+******************************************************************/
+static int ipmi_get_power_consumption_data(void* intf,uint8_t unit)
+{
+    int rc = 0;
+    SensorReadingType sensorReadingData;
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; 
+    struct sdr_record_list *sdr = NULL;
+    uchar sdrbuf[SDR_SZ];
+    double readingf, warningf, failuref;
+    int readingbtuphr=0;
+    int warning_threshbtuphr=0;
+    int failure_thresbtuphr=0;
+    int status=0;
+    int sensor_number = 0;
+
+    if (sdrfile != NULL) {
+        rc = get_sdr_file(sdrfile,&sdrcache);
+        if (rc) printf ("Error 0x%02x: Cannot get SDRs from %s\n",rc,sdrfile);
+    } else if (sdrcache == NULL) {
+	rc = get_sdr_cache(&sdrcache);
+        if (rc) printf ("Error 0x%02x: Cannot get SDRs\n",rc);
+    }
+
+    rc = find_sdr_by_tag(sdrbuf, sdrcache, "System Level", fdebug);
+    if (rc != 0)
+    {
+        printf ("Error %d: Cannot access the System Level sensor data\n",rc);
+        return rc;
+    }
+    sdr = (struct sdr_record_list *)sdrbuf;
+
+    sensor_number = sdrbuf[7]; // sdr->record.full->keys.sensor_num;
+    if (fdebug) printf("calling GetSensorReading(%x)\n",sensor_number);
+    rc = GetSensorReading(sensor_number, sdrbuf, 
+			  (uchar *)&sensorReadingData.sensorReading);
+    if (rc != 0) 
+	printf("Error %d getting sensor %x reading\n",rc,sensor_number);
+
+    rc = GetSensorThresholds( sensor_number, rsp);
+    if (fdebug) printf("GetSensorThresholds(%x) rc = %d\n",sensor_number,rc);
+    if (rc == 0)
+    {   
+        readingf = RawToFloat(sensorReadingData.sensorReading,sdrbuf);
+        warningf = RawToFloat(rsp[4], sdrbuf);
+        failuref = RawToFloat(rsp[5], sdrbuf);
+        readingbtuphr = (int)readingf;
+        warning_threshbtuphr = (int)warningf;
+        failure_thresbtuphr = (int)failuref;
+
+	if (fdebug) {
+	   printf("Reading 0x%02x = %.2f, Warning 0x%02x = %.2f, Failure 0x%02x = %.2f\n",
+		sensorReadingData.sensorReading, readingf,
+		rsp[4], warningf, rsp[5], failuref);
+	}
+
+        printf ("System Board System Level\n\r");
+        if (unit==btuphr)
+        {
+            readingbtuphr= watt_to_btuphr_conversion(readingbtuphr);
+            warning_threshbtuphr= watt_to_btuphr_conversion(warning_threshbtuphr);
+            failure_thresbtuphr= watt_to_btuphr_conversion( failure_thresbtuphr);
+
+            printf ("Reading                : %d BTU/hr\n",readingbtuphr);
+            printf ("Warning threshold      : %d BTU/hr\n",warning_threshbtuphr);
+            printf ("Failure threshold      : %d BTU/hr\n",failure_thresbtuphr);
+        }
+        else
+        {
+            printf ("Reading                : %d W \n",readingbtuphr);              
+            printf ("Warning threshold      : %d W \n",(warning_threshbtuphr));
+            printf ("Failure threshold      : %d W \n",(failure_thresbtuphr));
+        }
+    }
+    else
+    {
+        printf ("Error %d: Cannot access the System Level threshold data\n",rc);
+        return -1;              
+    }       
+    return status;
+}
+
+
+
+
+/*****************************************************************
+* Function Name:      ipmi_get_instan_power_consmpt_data
+*
+* Description:        This function updates the instant Power consumption information
+* Input:              intf - ipmi interface
+* Output:             instpowerconsumptiondata - instant Power consumption information
+*
+* Return:              
+*
+******************************************************************/
+
+static int ipmi_get_instan_power_consmpt_data(void* intf,
+                                              IPMI_INST_POWER_CONSUMPTION_DATA* instpowerconsumptiondata)
+{
+
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req={0};
+
+    uint8_t msg_data[2];
+
+
+    /*get instantaneous power consumption command*/
+    req.msg.netfn = IPMI_DELL_OEM_NETFN;
+    req.msg.lun = 0;
+    req.msg.cmd = GET_PWR_CONSUMPTION_CMD;
+
+    req.msg.data = msg_data;
+    req.msg.data_len = 2;
+
+
+
+    memset(msg_data, 0, 2);
+
+    msg_data[0] = 0x0A;     
+    msg_data[1] = 0x00;
+
+
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+	printf(" Error getting power consumption data: ");
+	if (rv < 0) printf("no response\n");
+	else if((iDRAC_FLAG == IDRAC_12G) && (rv == LICENSE_NOT_SUPPORTED)) {
+		printf("FM001 : A required license is missing or expired\n");
+		return rv;	
+	} 
+	else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+	return rv;
+    }
+
+    * instpowerconsumptiondata = * ( (IPMI_INST_POWER_CONSUMPTION_DATA*) (rsp));
+#if WORDS_BIGENDIAN
+    instpowerconsumptiondata->instanpowerconsumption = BSWAP_16(instpowerconsumptiondata->instanpowerconsumption);
+    instpowerconsumptiondata->instanApms = BSWAP_16(instpowerconsumptiondata->instanApms);
+    instpowerconsumptiondata->resv1 = BSWAP_16(instpowerconsumptiondata->resv1);
+#endif
+
+    return 0;
+
+
+}
+
+
+/*****************************************************************
+* Function Name:      ipmi_print_get_instan_power_Amps_data
+*
+* Description:        This function prints the instant Power consumption information
+* Input:              instpowerconsumptiondata - instant Power consumption information
+* Output:               
+*
+* Return:              
+*
+******************************************************************/
+static void ipmi_print_get_instan_power_Amps_data(IPMI_INST_POWER_CONSUMPTION_DATA instpowerconsumptiondata)
+{
+    uint16_t intampsval=0;
+    uint16_t decimalampsval=0;
+
+
+    if (instpowerconsumptiondata.instanApms>0)
+    {
+        decimalampsval=(instpowerconsumptiondata.instanApms%10);
+        intampsval=instpowerconsumptiondata.instanApms/10;
+    }
+    printf("\nAmperage value: %d.%d A \n",intampsval,decimalampsval);
+}
+/*****************************************************************
+* Function Name:     ipmi_print_get_power_consmpt_data
+*
+* Description:       This function prints the Power consumption information
+* Input:             intf            - ipmi interface
+*                    unit            - watt / btuphr 
+* Output:               
+*
+* Return:              
+*
+******************************************************************/
+static int ipmi_print_get_power_consmpt_data(void* intf,uint8_t  unit)
+{
+
+    int rc = 0;
+    IPMI_INST_POWER_CONSUMPTION_DATA instpowerconsumptiondata = {0,0,0,0};
+    // int i;
+    //uint16_t inputwattageL=0;
+    //int sensorIndex = 0;
+    //uint32_t readingbtuphr;
+    //uint32_t warning_threshbtuphr;
+    //uint32_t failure_thresbtuphr;
+
+    printf ("\nPower consumption information\n");
+
+
+    rc=ipmi_get_power_consumption_data(intf,unit);
+    if (-1 == rc)
+        return rc;
+
+    rc=ipmi_get_instan_power_consmpt_data(intf,&instpowerconsumptiondata);
+    if (-1 == rc)
+        return rc;
+
+    ipmi_print_get_instan_power_Amps_data(instpowerconsumptiondata);
+
+
+    rc=ipmi_get_power_headroom_command(intf,unit);      
+
+    if (-1 == rc)
+        return rc;
+
+    return rc;
+
+
+}
+
+
+/*****************************************************************
+* Function Name:   ipmi_get_avgpower_consmpt_history
+*
+* Description:     This function updates the average power consumption information
+* Input:           intf            - ipmi interface
+* Output:          pavgpower- average power consumption information
+*
+* Return:              
+*
+******************************************************************/
+static int ipmi_get_avgpower_consmpt_history(void* intf,IPMI_AVGPOWER_CONSUMP_HISTORY* pavgpower )
+{
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req = {0};
+    uint8_t data[4];
+
+    req.msg.netfn = IPMI_NETFN_APP;
+    req.msg.lun = 0;
+    req.msg.cmd = IPMI_GET_SYS_INFO;
+    req.msg.data_len = 4;
+    req.msg.data = data;
+    data[0] = 0;
+    data[1] = 0xeb;
+    data[2] = 0;
+    data[3] = 0;
+
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+	printf(" Error getting average power consumption data: ");
+	if (rv < 0) printf("no response\n");
+	else if((iDRAC_FLAG == IDRAC_12G) && (rv == LICENSE_NOT_SUPPORTED)) {
+		printf("FM001 : A required license is missing or expired\n");
+		return rv;	
+	}
+	else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+	return rv;
+    }
+
+    if (verbose > 1)
+    {
+        printf("Average power consumption history  Data               :%x %x %x %x %x %x %x %x\n\n",
+            rsp[0], rsp[1], rsp[2], rsp[3], 
+            rsp[4], rsp[5], rsp[6], rsp[7]);
+
+    }
+
+    *pavgpower = *( (IPMI_AVGPOWER_CONSUMP_HISTORY*) rsp);
+#if WORDS_BIGENDIAN
+    pavgpower->lastminutepower = BSWAP_16(pavgpower->lastminutepower);
+    pavgpower->lasthourpower = BSWAP_16(pavgpower->lasthourpower);
+    pavgpower->lastdaypower = BSWAP_16(pavgpower->lastdaypower);
+    pavgpower->lastweakpower = BSWAP_16(pavgpower->lastweakpower);
+#endif
+
+    return 0;
+}
+
+/*****************************************************************
+* Function Name:    ipmi_get_peakpower_consmpt_history
+*
+* Description:      This function updates the peak power consumption information
+* Input:            intf            - ipmi interface
+* Output:           pavgpower- peak power consumption information
+*
+* Return:         
+*
+******************************************************************/
+static int ipmi_get_peakpower_consmpt_history(void* intf,IPMI_POWER_CONSUMP_HISTORY * pstPeakpower)
+{
+
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req = {0};
+    uint8_t data[4];
+
+    req.msg.netfn = IPMI_NETFN_APP;
+    req.msg.lun = 0;
+    req.msg.cmd = IPMI_GET_SYS_INFO;
+    req.msg.data_len = 4;
+    req.msg.data = data;
+    data[0] = 0;
+    data[1] = 0xec;
+    data[2] = 0;
+    data[3] = 0;
+
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+	printf(" Error getting peak power consumption history: ");
+	if (rv < 0) printf("no response\n");
+	else if((iDRAC_FLAG == IDRAC_12G) && (rv == LICENSE_NOT_SUPPORTED)) {
+		printf("FM001 : A required license is missing or expired\n");
+		return rv;	
+	} 
+	else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+	return rv;
+    }
+
+    if (verbose > 1)
+    {
+        printf("Peak power consmhistory  Data               : %x %x %x %x %x %x %x %x %x %x\n   %x %x %x %x %x %x %x %x %x %x %x %x %x\n\n",
+            rsp[0], rsp[1], rsp[2], rsp[3], 
+            rsp[4], rsp[5], rsp[6], rsp[7], 
+            rsp[8], rsp[9], rsp[10], rsp[11], 
+            rsp[12], rsp[13], rsp[14], rsp[15], 
+            rsp[16], rsp[17], rsp[18], rsp[19],  
+            rsp[20], rsp[21], rsp[22], rsp[23]
+        );
+
+    }
+    *pstPeakpower =* ((IPMI_POWER_CONSUMP_HISTORY*)rsp);
+#if WORDS_BIGENDIAN
+    pstPeakpower->lastminutepower = BSWAP_16(pstPeakpower->lastminutepower);
+    pstPeakpower->lasthourpower = BSWAP_16(pstPeakpower->lasthourpower);
+    pstPeakpower->lastdaypower = BSWAP_16(pstPeakpower->lastdaypower);
+    pstPeakpower->lastweakpower = BSWAP_16(pstPeakpower->lastweakpower);
+    pstPeakpower->lastminutepowertime = BSWAP_32(pstPeakpower->lastminutepowertime);
+    pstPeakpower->lasthourpowertime = BSWAP_32(pstPeakpower->lasthourpowertime);
+    pstPeakpower->lastdaypowertime = BSWAP_32(pstPeakpower->lastdaypowertime);
+    pstPeakpower->lastweekpowertime = BSWAP_32(pstPeakpower->lastweekpowertime);
+#endif
+    return 0;
+}
+
+
+/*****************************************************************
+* Function Name:    ipmi_get_minpower_consmpt_history
+*
+* Description:      This function updates the peak power consumption information
+* Input:            intf            - ipmi interface
+* Output:           pavgpower- peak power consumption information
+*
+* Return:         
+*
+******************************************************************/
+static int ipmi_get_minpower_consmpt_history(void* intf,IPMI_POWER_CONSUMP_HISTORY * pstMinpower)
+{
+
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req = {0};
+    uint8_t data[4];
+
+    req.msg.netfn = IPMI_NETFN_APP;
+    req.msg.lun = 0;
+    req.msg.cmd = IPMI_GET_SYS_INFO;
+    req.msg.data_len = 4;
+    req.msg.data = data;
+    data[0] = 0;
+    data[1] = 0xed;
+    data[2] = 0;
+    data[3] = 0;
+
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+	printf(" Error getting min power consumption history: ");
+	if (rv < 0) printf("no response\n");
+	else if((iDRAC_FLAG == IDRAC_12G) && (rv == LICENSE_NOT_SUPPORTED)) {
+		printf("FM001 : A required license is missing or expired\n");
+		return rv;	
+	}
+	else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+	return rv;
+    }
+
+    if (verbose > 1)
+    {
+        printf("Peak power consmhistory  Data               : %x %x %x %x %x %x %x %x %x %x\n   %x %x %x %x %x %x %x %x %x %x %x %x %x\n\n",
+            rsp[0], rsp[1], rsp[2], rsp[3], 
+            rsp[4], rsp[5], rsp[6], rsp[7], 
+            rsp[8], rsp[9], rsp[10], rsp[11], 
+            rsp[12], rsp[13], rsp[14], rsp[15], 
+            rsp[16], rsp[17], rsp[18], rsp[19],  
+            rsp[20], rsp[21], rsp[22], rsp[23]
+        );
+
+    }
+    *pstMinpower =* ((IPMI_POWER_CONSUMP_HISTORY*)rsp);
+#if WORDS_BIGENDIAN
+    pstMinpower->lastminutepower = BSWAP_16(pstMinpower->lastminutepower);
+    pstMinpower->lasthourpower = BSWAP_16(pstMinpower->lasthourpower);
+    pstMinpower->lastdaypower = BSWAP_16(pstMinpower->lastdaypower);
+    pstMinpower->lastweakpower = BSWAP_16(pstMinpower->lastweakpower);
+    pstMinpower->lastminutepowertime = BSWAP_32(pstMinpower->lastminutepowertime);
+    pstMinpower->lasthourpowertime = BSWAP_32(pstMinpower->lasthourpowertime);
+    pstMinpower->lastdaypowertime = BSWAP_32(pstMinpower->lastdaypowertime);
+    pstMinpower->lastweekpowertime = BSWAP_32(pstMinpower->lastweekpowertime);
+#endif
+    return 0;
+}
+
+
+
+/*****************************************************************
+* Function Name:    ipmi_print_power_consmpt_history
+*
+* Description:      This function print the average and peak power consumption information
+* Input:            intf      - ipmi interface
+*                   unit      - watt / btuphr
+* Output:                
+*
+* Return:              
+*
+******************************************************************/
+static int ipmi_print_power_consmpt_history(void* intf,int unit )
+{
+
+    char timestr[30];
+
+    uint32_t lastminutepeakpower;
+    uint32_t lasthourpeakpower;
+    uint32_t lastdaypeakpower;
+    uint32_t lastweekpeakpower;
+
+    IPMI_AVGPOWER_CONSUMP_HISTORY avgpower;
+    IPMI_POWER_CONSUMP_HISTORY stMinpower;
+    IPMI_POWER_CONSUMP_HISTORY stPeakpower;
+    int rc=0;
+
+    uint64_t tempbtuphrconv;
+    //uint16_t temp;
+
+
+    rc= ipmi_get_avgpower_consmpt_history(intf,&avgpower);    
+    if (-1 == rc)
+        return rc;
+
+    rc= ipmi_get_peakpower_consmpt_history(intf,&stPeakpower);
+    if (-1 == rc)
+        return rc;
+
+    rc= ipmi_get_minpower_consmpt_history(intf,&stMinpower);
+    if (-1 == rc)
+        return rc;
+
+
+    if(rc==0) 
+    {
+        printf ("Power Consumption History\n\r\n\r");
+        /* The fields are alligned manually changing the spaces will alter the alignment*/
+        printf ("Statistic                   Last Minute     Last Hour     Last Day     Last Week\n\r\n\r");
+
+        if (unit ==btuphr)
+        {
+            printf ("Average Power Consumption  ");         
+            tempbtuphrconv=watt_to_btuphr_conversion(avgpower.lastminutepower);
+            printf ("%4d BTU/hr     ",tempbtuphrconv);
+            tempbtuphrconv=watt_to_btuphr_conversion(avgpower.lasthourpower);
+            printf ("%4d BTU/hr   ",tempbtuphrconv);
+            tempbtuphrconv=watt_to_btuphr_conversion(avgpower.lastdaypower);
+            printf ("%4d BTU/hr  ",tempbtuphrconv);
+            tempbtuphrconv=watt_to_btuphr_conversion(avgpower.lastweakpower);
+            printf ("%4d BTU/hr\n\r",tempbtuphrconv);
+
+            printf ("Max Power Consumption      ");         
+            tempbtuphrconv=watt_to_btuphr_conversion(stPeakpower.lastminutepower);
+            printf ("%4d BTU/hr     ",tempbtuphrconv);
+            tempbtuphrconv=watt_to_btuphr_conversion(stPeakpower.lasthourpower);
+            printf ("%4d BTU/hr   ",tempbtuphrconv);
+            tempbtuphrconv=watt_to_btuphr_conversion(stPeakpower.lastdaypower);
+            printf ("%4d BTU/hr  ",tempbtuphrconv);
+            tempbtuphrconv=watt_to_btuphr_conversion(stPeakpower.lastweakpower);
+            printf ("%4d BTU/hr\n\r",tempbtuphrconv);
+
+            printf ("Min Power Consumption      ");         
+            tempbtuphrconv=watt_to_btuphr_conversion(stMinpower.lastminutepower);
+            printf ("%4d BTU/hr     ",tempbtuphrconv);
+            tempbtuphrconv=watt_to_btuphr_conversion(stMinpower.lasthourpower);
+            printf ("%4d BTU/hr   ",tempbtuphrconv);
+            tempbtuphrconv=watt_to_btuphr_conversion(stMinpower.lastdaypower);
+            printf ("%4d BTU/hr  ",tempbtuphrconv);
+            tempbtuphrconv=watt_to_btuphr_conversion(stMinpower.lastweakpower);
+            printf ("%4d BTU/hr\n\r\n\r",tempbtuphrconv);
+
+        }
+        else
+        {
+
+            printf ("Average Power Consumption  ");         
+            tempbtuphrconv=(avgpower.lastminutepower);
+			printf ("%4ld W          ",tempbtuphrconv);
+			tempbtuphrconv=(avgpower.lasthourpower);
+			printf ("%4ld W        ",tempbtuphrconv);
+			tempbtuphrconv=(avgpower.lastdaypower);
+			printf ("%4ld W       ",tempbtuphrconv);
+			tempbtuphrconv=(avgpower.lastweakpower);
+			printf ("%4ld W   \n\r",tempbtuphrconv);
+
+		printf ("Max Power Consumption      ");		
+			tempbtuphrconv=(stPeakpower.lastminutepower);
+			printf ("%4ld W          ",tempbtuphrconv);
+			tempbtuphrconv=(stPeakpower.lasthourpower);
+			printf ("%4ld W        ",tempbtuphrconv);
+			tempbtuphrconv=(stPeakpower.lastdaypower);
+			printf ("%4ld W       ",tempbtuphrconv);
+			tempbtuphrconv=(stPeakpower.lastweakpower);
+			printf ("%4ld W   \n\r",tempbtuphrconv);
+
+		printf ("Min Power Consumption      ");		
+			tempbtuphrconv=(stMinpower.lastminutepower);
+			printf ("%4ld W          ",tempbtuphrconv);
+			tempbtuphrconv=(stMinpower.lasthourpower);
+			printf ("%4ld W        ",tempbtuphrconv);
+			tempbtuphrconv=(stMinpower.lastdaypower);
+			printf ("%4ld W       ",tempbtuphrconv);
+			tempbtuphrconv=(stMinpower.lastweakpower);
+		   	printf ("%4ld W   \n\r\n\r",tempbtuphrconv);
+		}		
+		
+        lastminutepeakpower=stPeakpower.lastminutepowertime;
+        lasthourpeakpower=stPeakpower.lasthourpowertime;
+        lastdaypeakpower=stPeakpower.lastdaypowertime;
+        lastweekpeakpower=stPeakpower.lastweekpowertime;
+
+        printf ("Max Power Time\n\r");
+        ipmi_time_to_str(lastminutepeakpower, timestr);         
+        printf ("Last Minute     : %s",timestr);
+        ipmi_time_to_str(lasthourpeakpower, timestr);           
+        printf ("Last Hour       : %s",timestr);
+        ipmi_time_to_str(lastdaypeakpower, timestr);            
+        printf ("Last Day        : %s",timestr);
+        ipmi_time_to_str(lastweekpeakpower, timestr);           
+        printf ("Last Week       : %s",timestr);                
+
+
+        lastminutepeakpower=stMinpower.lastminutepowertime;
+        lasthourpeakpower=stMinpower.lasthourpowertime;
+        lastdaypeakpower=stMinpower.lastdaypowertime;
+        lastweekpeakpower=stMinpower.lastweekpowertime; 
+
+        printf ("Min Power Time\n\r");
+        ipmi_time_to_str(lastminutepeakpower, timestr);         
+        printf ("Last Minute     : %s",timestr);
+        ipmi_time_to_str(lasthourpeakpower, timestr);           
+        printf ("Last Hour       : %s",timestr);
+        ipmi_time_to_str(lastdaypeakpower, timestr);            
+        printf ("Last Day        : %s",timestr);
+        ipmi_time_to_str(lastweekpeakpower, timestr);           
+        printf ("Last Week       : %s",timestr);        
+
+    }
+	return rc;
+
+}
+
+
+
+/*****************************************************************
+* Function Name:    ipmi_get_power_cap
+*
+* Description:      This function updates the power cap information
+* Input:            intf         - ipmi interface
+* Output:           ipmipowercap - power cap information
+*
+* Return:          
+*
+******************************************************************/
+
+static int ipmi_get_power_cap(void* intf,IPMI_POWER_CAP* ipmipowercap )
+{
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req={0};
+    //uint64_t tempbtuphrconv;
+    uint8_t data[4];
+
+    /* power supply rating command*/
+    req.msg.netfn = IPMI_NETFN_APP;
+    req.msg.lun = 0;
+    req.msg.cmd = IPMI_GET_SYS_INFO;
+    req.msg.data_len = 4;
+    req.msg.data = data;
+
+    data[0] = 0;
+    data[1] = IPMI_DELL_POWER_CAP;
+    data[2] = 0;
+    data[3] = 0;
+
+
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+	printf(" Error getting power cap: ");
+	if (rv < 0) printf("no response\n");
+	else if((iDRAC_FLAG == IDRAC_12G) && (rv == LICENSE_NOT_SUPPORTED)) {
+		printf("FM001 : A required license is missing or expired\n");
+		return rv;	
+	} 
+	else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+	return rv;
+    }
+    if (verbose > 1){
+        printf("power cap  Data               :%x %x %x %x %x %x %x %x %x %x %x",
+            rsp[1], rsp[2], rsp[3], 
+            rsp[4], rsp[5], rsp[6], rsp[7], 
+            rsp[8], rsp[9], rsp[10],rsp[11]);
+
+    }
+
+    * ipmipowercap = *((IPMI_POWER_CAP*)(rsp));
+#if WORDS_BIGENDIAN
+    ipmipowercap->PowerCap = BSWAP_16(ipmipowercap->PowerCap);
+    ipmipowercap->MaximumPowerConsmp = BSWAP_16(ipmipowercap->MaximumPowerConsmp);
+    ipmipowercap->MinimumPowerConsmp = BSWAP_16(ipmipowercap->MinimumPowerConsmp);
+    ipmipowercap->totalnumpowersupp = BSWAP_16(ipmipowercap->totalnumpowersupp);
+    ipmipowercap->AvailablePower = BSWAP_16(ipmipowercap->AvailablePower);
+    ipmipowercap->SystemThrottling = BSWAP_16(ipmipowercap->SystemThrottling);
+    ipmipowercap->Resv = BSWAP_16(ipmipowercap->Resv);
+#endif
+
+    return 0;
+}
+
+/*****************************************************************
+* Function Name:    ipmi_print_power_cap
+*
+* Description:      This function print the power cap information
+* Input:            intf            - ipmi interface
+*                   unit            - watt / btuphr
+* Output:                
+* Return:               
+*
+******************************************************************/
+static int ipmi_print_power_cap(void* intf,uint8_t unit )
+{
+    uint64_t tempbtuphrconv;
+    int rc;
+    IPMI_POWER_CAP ipmipowercap;
+
+	memset(&ipmipowercap,0,sizeof(ipmipowercap));
+    rc=ipmi_get_power_cap(intf,&ipmipowercap);
+
+
+    if (rc==0) 
+    {
+        if (unit ==btuphr){
+            tempbtuphrconv=watt_to_btuphr_conversion(ipmipowercap.MaximumPowerConsmp);
+			printf ("Maximum power: %ld  BTU/hr\n",tempbtuphrconv);
+			tempbtuphrconv=watt_to_btuphr_conversion(ipmipowercap.MinimumPowerConsmp);
+			printf ("Minimum power: %ld  BTU/hr\n",tempbtuphrconv);
+			tempbtuphrconv=watt_to_btuphr_conversion(ipmipowercap.PowerCap);
+			printf ("Power cap    : %ld  BTU/hr\n",tempbtuphrconv);
+		}else{
+		
+			printf ("Maximum power: %ld Watt\n",ipmipowercap.MaximumPowerConsmp);
+			printf ("Minimum power: %ld Watt\n",ipmipowercap.MinimumPowerConsmp);
+			printf ("Power cap    : %ld Watt\n",ipmipowercap.PowerCap);
+        }
+    }
+    return rc;
+
+}  
+
+/*****************************************************************
+* Function Name:     ipmi_set_power_cap
+*
+* Description:       This function updates the power cap information
+* Input:             intf            - ipmi interface
+*                    unit            - watt / btuphr
+*                    val             - new power cap value
+* Output:          
+* Return:               
+*
+******************************************************************/
+static int ipmi_set_power_cap(void* intf,int unit,int val )
+{
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req={0};
+    uint8_t data[13];
+    uint16_t powercapval;
+    uint64_t maxpowerbtuphr;
+    uint64_t maxpowerbtuphr1;
+    uint64_t minpowerbtuphr;
+    IPMI_POWER_CAP ipmipowercap;
+
+	if(ipmi_get_power_capstatus_command(intf) < 0)
+		return -1;	// Adding the failed condition check
+
+    if (PowercapSetable_flag!=1)
+    {
+        lprintf(LOG_ERR, " Can not set powercap on this system");
+        return -1;
+    }
+    else if(PowercapstatusFlag!=1)
+    {
+        lprintf(LOG_ERR, " Power cap set feature is not enabled");
+        return -1;
+    }
+
+    req.msg.netfn = IPMI_NETFN_APP;
+    req.msg.lun = 0;
+    req.msg.cmd = IPMI_GET_SYS_INFO;
+    req.msg.data_len = 4;
+    memset(data, 0, 4);
+    req.msg.data = data;
+
+    data[0] = 0;
+    data[1] = IPMI_DELL_POWER_CAP;
+    data[2] = 0;
+    data[3] = 0;
+
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+	printf(" Error getting power cap: ");
+	if (rv < 0) printf("no response\n");
+	else if((iDRAC_FLAG == IDRAC_12G) && (rv == LICENSE_NOT_SUPPORTED)) {
+		printf("FM001 : A required license is missing or expired\n");
+		return rv;	
+	}
+	else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+	return rv;
+    }
+    if (verbose > 1)
+    {
+        printf("power cap  Data               :%x %x %x %x %x %x %x %x %x %x ",
+            rsp[1], rsp[2], rsp[3], 
+            rsp[4], rsp[5], rsp[6], rsp[7], 
+            rsp[8], rsp[9], rsp[10],rsp[11]);
+
+    }
+
+    ipmipowercap.PowerCap=((rsp[1]<<8)+rsp[2]);
+    ipmipowercap.unit=rsp[3];
+    ipmipowercap.MaximumPowerConsmp=((rsp[4]<<8)+rsp[5]);
+    ipmipowercap.MinimumPowerConsmp=((rsp[6]<<8)+rsp[7]);
+    /* ARC: need Dell to verify these 3 values */
+    ipmipowercap.totalnumpowersupp = rsp[8];
+    ipmipowercap.AvailablePower = ((rsp[9]<<8)+rsp[10]);
+    ipmipowercap.SystemThrottling = rsp[11];
+
+    memset(data, 0, 13);
+    req.msg.netfn = IPMI_NETFN_APP;
+    req.msg.lun = 0;
+    req.msg.cmd = IPMI_SET_SYS_INFO;
+    req.msg.data_len = 13;
+    req.msg.data = data;
+    data[0] = IPMI_DELL_POWER_CAP;
+    powercapval=val;
+
+
+    data[1] = (powercapval&0XFF);                   
+    data[2] = ((powercapval&0XFF00)>>8);
+    data[3] = unit;
+
+    data[4]=((ipmipowercap.MaximumPowerConsmp&0xFF));
+    data[5]=((ipmipowercap.MaximumPowerConsmp&0xFF00)>>8);
+    data[6]=((ipmipowercap.MinimumPowerConsmp&0xFF));
+    data[7]=((ipmipowercap.MinimumPowerConsmp&0xFF00)>>8);
+    data[8]=(uint8_t)(ipmipowercap.totalnumpowersupp);  
+    data[9]=((ipmipowercap.AvailablePower&0xFF));
+    data[10]=((ipmipowercap.AvailablePower&0xFF00)>>8);
+    data[11]=(uint8_t)(ipmipowercap.SystemThrottling);
+    data[12]=0x00;
+
+    ipmipowercap.MaximumPowerConsmp = BSWAP_16(ipmipowercap.MaximumPowerConsmp);
+    ipmipowercap.MinimumPowerConsmp = BSWAP_16(ipmipowercap.MinimumPowerConsmp);
+    ipmipowercap.PowerCap = BSWAP_16(ipmipowercap.PowerCap);
+    if(unit==btuphr)
+    {
+        val = btuphr_to_watt_conversion(val);
+
+    }
+    else if(unit ==percent)
+    {
+       	if((val <0)||(val>100))
+        {
+            lprintf(LOG_ERR, " Cap value is out of boundary conditon it should be between 0  - 100");
+            return -1;
+        }
+        val =( (val*(ipmipowercap.MaximumPowerConsmp -ipmipowercap.MinimumPowerConsmp))/100)+ipmipowercap.MinimumPowerConsmp;
+        lprintf(LOG_ERR, " Cap value in percentage is  %d ",val);
+        data[1] = (val&0XFF);                   
+        data[2] = ((val&0XFF00)>>8);
+        data[3] = watt;
+    }
+    if(((val<ipmipowercap.MinimumPowerConsmp)||(val>ipmipowercap.MaximumPowerConsmp))&&(unit==watt))
+    {
+        lprintf(LOG_ERR, " Cap value is out of boundary conditon it should be between %d  - %d",
+            ipmipowercap.MinimumPowerConsmp,ipmipowercap.MaximumPowerConsmp);
+        return -1;
+    }
+    else if(((val<ipmipowercap.MinimumPowerConsmp)||(val>ipmipowercap.MaximumPowerConsmp))&&(unit==btuphr))
+    {
+        minpowerbtuphr= watt_to_btuphr_conversion(ipmipowercap.MinimumPowerConsmp);
+        maxpowerbtuphr=watt_to_btuphr_conversion(ipmipowercap.MaximumPowerConsmp);
+        maxpowerbtuphr1= watt_to_btuphr_conversion(ipmipowercap.MaximumPowerConsmp);
+        lprintf(LOG_ERR, " Cap value is out of boundary conditon it should be between %d",
+            minpowerbtuphr);
+        lprintf(LOG_ERR, " -%d",
+            maxpowerbtuphr1);
+
+        return -1;
+    }
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+	printf(" Error setting power cap: ");
+	if (rv < 0) printf("no response\n");
+	else if((iDRAC_FLAG == IDRAC_12G) && (rv == LICENSE_NOT_SUPPORTED)) {
+		printf("FM001 : A required license is missing or expired\n");
+		return rv;	
+	} 
+	else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+	return rv;
+    }
+    if (verbose > 1)
+    {
+        printf("CC for setpowercap :%d ",rv);
+    }
+    return 0;
+}
+
+#ifdef NOT_USED
+static int getpowersupplyfruinfo(void *intf, uint8_t id, 
+                       struct fru_header header, struct fru_info fru);
+/*****************************************************************
+* Function Name:    getpowersupplyfruinfo
+*
+* Description:      This function retrieves the FRU header
+* Input:            intf    - ipmi interface
+*                   header  - watt / btuphr
+*                   fru     - FRU information
+* Output:           header  - FRU header
+* Return:           
+*
+******************************************************************/
+static int getpowersupplyfruinfo(void *intf, uint8_t id, 
+                         struct fru_header header, struct fru_info fru)
+{
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req;
+
+    uint8_t msg_data[4];
+
+    memset(&fru, 0, sizeof(struct fru_info));
+    memset(&header, 0, sizeof(struct fru_header));
+
+    /*
+    * get info about this FRU
+    */
+    memset(msg_data, 0, 4);
+    msg_data[0] = id;
+
+    memset(&req, 0, sizeof(req));
+    req.msg.netfn = IPMI_NETFN_STORAGE;
+    req.msg.lun = 0;
+    req.msg.cmd = GET_FRU_INFO;
+    req.msg.data = msg_data;
+    req.msg.data_len = 1;
+
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+	printf(" Device not present, ");
+	if (rv < 0) printf("no response\n");
+	else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+	return rv;
+    }
+
+    fru.size = (rsp[1] << 8) | rsp[0];
+    fru.access = rsp[2] & 0x1;
+
+    lprintf(LOG_DEBUG, "fru.size = %d bytes (accessed by %s)",
+        fru.size, fru.access ? "words" : "bytes");
+
+    if (fru.size < 1) {
+        printf(" Invalid FRU size %d", fru.size);
+        return -1;
+    }
+
+    /*
+    * retrieve the FRU header
+    */
+    msg_data[0] = id;
+    msg_data[1] = 0;
+    msg_data[2] = 0;
+    msg_data[3] = 8;
+
+    memset(&req, 0, sizeof(req));
+    req.msg.netfn = IPMI_NETFN_STORAGE;
+    req.msg.lun = 0;
+    req.msg.cmd = GET_FRU_DATA;
+    req.msg.data = msg_data;
+    req.msg.data_len = 4;
+
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+	printf(" Device not present, ");
+	if (rv < 0) printf("no response\n");
+	else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+	return rv;
+    }
+
+    if (verbose > 1)
+        printbuf(rsp, rsp_len, "FRU DATA");
+
+    memcpy(&header, &rsp[1], 8);
+
+	return 0;
+
+
+}
+#endif
+
+/*****************************************************************
+* Function Name:   ipmi_powermonitor_usage
+*
+* Description:     This function prints help message for powermonitor command
+* Input:              
+* Output:       
+*
+* Return:              
+*
+******************************************************************/
+static void
+ipmi_powermonitor_usage(void)
+{
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "   powermonitor");
+    lprintf(LOG_NOTICE, "      Shows power tracking statistics ");
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "   powermonitor clear cumulativepower");
+    lprintf(LOG_NOTICE, "      Reset cumulative power reading");
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "   powermonitor clear peakpower");
+    lprintf(LOG_NOTICE, "      Reset peak power reading");
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "   powermonitor powerconsumption");
+    lprintf(LOG_NOTICE, "      Displays power consumption in <watt|btuphr>");
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "   powermonitor powerconsumptionhistory <watt|btuphr>");
+    lprintf(LOG_NOTICE, "      Displays power consumption history ");
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "   powermonitor getpowerbudget");
+    lprintf(LOG_NOTICE, "      Displays power cap in <watt|btuphr>");
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "   powermonitor setpowerbudget <val><watt|btuphr|percent>");
+    lprintf(LOG_NOTICE, "      Allows user to set the  power cap in <watt|BTU/hr|percentage>");
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "   powermonitor enablepowercap ");
+    lprintf(LOG_NOTICE, "      To enable set power cap");
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "   powermonitor disablepowercap ");
+    lprintf(LOG_NOTICE, "      To disable set power cap");
+    lprintf(LOG_NOTICE, "");
+
+}
+/*****************************************************************
+* Function Name:	   ipmi_delloem_vFlash_main
+*
+* Description:		   This function processes the delloem vFlash command
+* Input:			   intf    - ipmi interface
+					   argc    - no of arguments
+					   argv    - argument string array
+* Output:		 
+*
+* Return:			   return code	   0 - success
+*						  -1 - failure
+*
+******************************************************************/
+
+static int ipmi_delloem_vFlash_main (void * intf, int  argc, char ** argv)
+{
+	int rc = 0;
+
+	current_arg++;
+	rc = ipmi_delloem_vFlash_process(intf, current_arg, argv);
+	return(rc);
+}
+
+
+
+/*****************************************************************
+* Function Name: 	get_vFlash_compcode_str
+*
+* Description: 	This function maps the vFlash completion code
+* 		to a string
+* Input : vFlash completion code and static array of codes vs strings
+* Output: - 		
+* Return: returns the mapped string		
+*
+******************************************************************/
+const char * 
+get_vFlash_compcode_str(uint8_t vflashcompcode, const struct vFlashstr *vs)
+{
+	static char un_str[32];
+	int i;
+
+	for (i = 0; vs[i].str != NULL; i++) {
+		if (vs[i].val == vflashcompcode)
+			return vs[i].str;
+	}
+
+	memset(un_str, 0, 32);
+	snprintf(un_str, 32, "Unknown (0x%02X)", vflashcompcode);
+
+	return un_str;
+}
+
+/*****************************************************************
+* Function Name: 	ipmi_get_sd_card_info
+*
+* Description: This function prints the vFlash Extended SD card info
+* Input : ipmi interface
+* Output: prints the sd card extended info		
+* Return: 0 - success -1 - failure
+*
+******************************************************************/
+static int
+ipmi_get_sd_card_info(void* intf) {
+	uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+	struct ipmi_rq req;
+
+	uint8_t msg_data[2];
+	uint8_t input_length=0;
+	uint8_t cardstatus=0x00;
+
+	IPMI_DELL_SDCARD_INFO * sdcardinfoblock;
+
+	input_length = 2;
+	msg_data[0] = msg_data[1] = 0x00;
+
+	req.msg.netfn = IPMI_DELL_OEM_NETFN;
+	req.msg.lun = 0;
+	req.msg.cmd = IPMI_GET_EXT_SD_CARD_INFO;
+	req.msg.data = msg_data;
+	req.msg.data_len = input_length;
+
+	rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+	if (rv) {
+	   printf(" Error getting SD Card Extended info, ");
+	   if (rv < 0) printf("no response\n");
+	   else printf("Completion Code 0x%02x %s\n",rv,decode_cc(0,rv));
+	   return rv;
+	}
+
+	sdcardinfoblock = (IPMI_DELL_SDCARD_INFO *) (void *) rsp;
+
+	if( (iDRAC_FLAG == IDRAC_12G) && (sdcardinfoblock->vflashcompcode == VFL_NOT_LICENSED))
+	{
+		printf("FM001 : A required license is missing or expired\n");
+		return -1;	
+	}
+	else if (sdcardinfoblock->vflashcompcode != 0x00)
+	{
+		lprintf(LOG_ERR, " Error in getting SD Card Extended Information (%s) \n", get_vFlash_compcode_str(sdcardinfoblock->vflashcompcode,
+					vFlash_completion_code_vals));
+		return -1;
+	}
+
+	if (!(sdcardinfoblock->sdcardstatus & 0x04))
+	{
+		lprintf(LOG_ERR, " vFlash SD card is unavailable, please insert the card\n of size 256MB or greater\n");
+		return 0;
+	}
+
+	printf("vFlash SD Card Properties\n");
+	printf("SD Card size       : %8dMB\n",sdcardinfoblock->sdcardsize);
+	printf("Available size     : %8dMB\n",sdcardinfoblock->sdcardavailsize);
+	printf("Initialized        : %10s\n", (sdcardinfoblock->sdcardstatus & 0x80) ?
+			"Yes" : "No");
+	printf("Licensed           : %10s\n", (sdcardinfoblock->sdcardstatus & 0x40) ?
+			"Yes" : "No");
+	printf("Attached           : %10s\n", (sdcardinfoblock->sdcardstatus & 0x20) ?
+			"Yes" : "No");
+	printf("Enabled            : %10s\n", (sdcardinfoblock->sdcardstatus & 0x10) ?
+			"Yes" : "No");
+	printf("Write Protected    : %10s\n", (sdcardinfoblock->sdcardstatus & 0x08) ?
+			"Yes" : "No");
+	cardstatus = sdcardinfoblock->sdcardstatus & 0x03;
+	printf("Health             : %10s\n", ((0x00 == cardstatus
+		) ? "OK" : ((cardstatus == 0x03) ? 
+			"Undefined" : ((cardstatus == 0x02) ? 
+				"Critical" : "Warning"))));
+	printf("Bootable partition : %10d\n",sdcardinfoblock->bootpartion);
+	return 0;
+}
+
+/*****************************************************************
+* Function Name: 	ipmi_delloem_vFlash_process
+*
+* Description: 	This function processes the args for vFlash subcmd
+* Input : intf - ipmi interface, arg index, argv array
+* Output: prints help or error with help
+* Return: 0 - Success -1 - failure
+*
+******************************************************************/
+static int
+ipmi_delloem_vFlash_process(void* intf, int current_arg, char ** argv) 
+{
+	int rc = 0;
+	int drv;
+
+	drv = get_driver_type();
+	if (drv != DRV_MV) /* MV open driver */
+	{
+		lprintf(LOG_ERR, " vFlash support is enabled only for wmi and open interface.\n Its not enabled for lan and lanplus interface.");
+		return -1;
+	}
+
+	if (argv[current_arg] == NULL || strcmp(argv[current_arg], "help") == 0)
+	{
+		ipmi_vFlash_usage();
+		return 0;
+	}
+	ipmi_idracvalidator_command(intf);
+	if (!strncmp(argv[current_arg], "info\0", 5))
+	{
+		current_arg++;
+		if (argv[current_arg] == NULL)
+		{
+			ipmi_vFlash_usage();
+			return -1;
+		}
+		else if (strncmp(argv[current_arg], "Card\0", 5) == 0)
+		{
+			current_arg++;
+			if (argv[current_arg] != NULL)
+			{
+				ipmi_vFlash_usage();
+				return -1;
+			}
+			rc = ipmi_get_sd_card_info(intf);
+			return rc;
+		}
+		else /* TBD: many sub commands are present */
+		{
+			ipmi_vFlash_usage();
+			return -1;
+		}
+	}
+	/* TBD other vFlash subcommands */
+	else
+	{
+		ipmi_vFlash_usage();
+		return -1;
+	}
+	return(rc);
+}
+
+/*****************************************************************
+* Function Name: 	ipmi_vFlash_usage
+*
+* Description: 	This function displays the usage for using vFlash
+* Input : void
+* Output: prints help		
+* Return: void	
+*
+******************************************************************/
+static void
+ipmi_vFlash_usage(void)
+{
+	lprintf(LOG_NOTICE, "");
+	lprintf(LOG_NOTICE, "   vFlash info Card");
+	lprintf(LOG_NOTICE, "      Shows Extended SD Card information");
+	lprintf(LOG_NOTICE, "");
+}
+/*****************************************************************
+* Function Name:       ipmi_delloem_windbg_main
+*
+* Description:         This function processes the delloem windbg command
+* Input:               intf    - ipmi interface
+                       argc    - no of arguments
+                       argv    - argument string array
+* Output:        
+*
+* Return:              return code     0 - success
+*                         -1 - failure
+*
+******************************************************************/
+
+static int ipmi_delloem_windbg_main (void * intf, int  argc, char ** argv)
+{
+    int rc = 0;
+
+	current_arg++;
+	if (argv[current_arg] == NULL)
+	{
+		ipmi_windbg_usage();
+		return -1;
+	}		
+	if (strncmp(argv[current_arg], "start\0", 6) == 0)
+	{
+		rc = ipmi_windbg_start(intf);
+	}
+	else if (strncmp(argv[current_arg], "end\0", 4) == 0)
+	{
+		rc = ipmi_windbg_end(intf);
+	}
+	else
+	{
+		ipmi_windbg_usage();
+	}
+	return(rc);
+}
+
+/*****************************************************************
+* Function Name: 	ipmi_windbg_start 
+*
+* Description: 	This function Starts the windbg
+* Input : void
+* Output: Start the debug		
+* Return: void	
+*
+******************************************************************/
+static int
+ipmi_windbg_start (void * intf)
+{
+	int rc;
+	lprintf(LOG_NOTICE, "Issuing sol activate");
+	lprintf(LOG_NOTICE, "");
+	
+	rc = ipmi_sol_activate(intf,0,0);
+	if (rc) lprintf(LOG_NOTICE, "Can not issue sol activate");
+	else windbgsession = 1;
+	return(rc);
+}
+
+/*****************************************************************
+* Function Name: 	ipmi_windbg_end
+*
+* Description: 	This function ends the windbg
+* Input : void
+* Output: End the debug		
+* Return: void	
+*
+******************************************************************/
+
+static int
+ipmi_windbg_end(void * intf)
+{
+	int rc;
+	lprintf(LOG_NOTICE, "Issuing sol deactivate");
+	lprintf(LOG_NOTICE, "");
+	rc = ipmi_sol_deactivate(intf);
+	if (rc) lprintf(LOG_NOTICE, "Can not issue sol deactivate");
+	else windbgsession = 0;
+	return(rc);	
+}
+
+
+/*****************************************************************
+* Function Name: 	ipmi_windbg_usage
+*
+* Description: 	This function displays the usage for using windbg
+* Input : void
+* Output: prints help		
+* Return: void	
+*
+******************************************************************/
+
+static void
+ipmi_windbg_usage(void)
+{
+	lprintf(LOG_NOTICE, "");
+	lprintf(LOG_NOTICE, "   windbg start");
+	lprintf(LOG_NOTICE, "      Starts the windbg session (Cold Reset & SOL Activation)");
+	lprintf(LOG_NOTICE, "");
+	lprintf(LOG_NOTICE, "   windbg end");
+	lprintf(LOG_NOTICE, "      Ends the windbg session (SOL Deactivation");
+	lprintf(LOG_NOTICE, "");
+}
+
+
+
+/**********************************************************************
+* Function Name: ipmi_setled_usage
+*
+* Description:  This function prints help message for setled command
+* Input:
+* Output:
+*
+* Return:
+*
+***********************************************************************/
+static void
+ipmi_setled_usage(void)
+{
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "   setled <b:d.f> <state..>");
+    lprintf(LOG_NOTICE, "      Set backplane LED state");
+    lprintf(LOG_NOTICE, "      b:d.f = PCI Bus:Device.Function of drive (lspci format)");
+    lprintf(LOG_NOTICE, "      state = present|online|hotspare|identify|rebuilding|");
+    lprintf(LOG_NOTICE, "              fault|predict|critical|failed");
+    lprintf(LOG_NOTICE, "");
+}
+
+static void
+ipmi_delloem_getled_usage(void)
+{
+    lprintf(LOG_NOTICE, "");
+    lprintf(LOG_NOTICE, "   getled ");
+    lprintf(LOG_NOTICE, "      Get Chassis ID LED state");
+    lprintf(LOG_NOTICE, "");
+}
+
+static int
+IsSetLEDSupported(void)
+{
+    return SetLEDSupported;
+}
+
+static int
+CheckSetLEDSupport(void * intf)
+{
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req = {0};
+    uint8_t data[10];
+
+    SetLEDSupported = 0;
+    req.msg.netfn = IPMI_DELL_OEM_NETFN;
+    req.msg.lun = 0;
+    req.msg.cmd = 0xD5; 		/* Storage */
+    req.msg.data_len = sizeof(data);    /*10*/
+    req.msg.data = data;
+
+    memset(data, 0, sizeof(data));
+    data[0] = 0x01;                        // get
+    data[1] = 0x00;			   // subcmd:get firmware version
+    data[2] = 0x08;                        // length lsb
+    data[3] = 0x00;			   // length msb
+    data[4] = 0x00;			   // offset lsb
+    data[5] = 0x00;			   // offset msb
+    data[6] = 0x00;			   // bay id
+    data[7] = 0x00;		
+    data[8] = 0x00;
+    data[9] = 0x00;
+
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv == 0) SetLEDSupported = 1;
+    return(rv);
+}
+
+/*****************************************************************
+* Function Name:    ipmi_getdrivemap
+*
+* Description:      This function returns mapping of BDF to Bay:Slot
+* Input:            intf         - ipmi interface
+*		    bdf	 	 - PCI Address of drive
+*		    *bay	 - Returns bay ID
+		    *slot	 - Returns slot ID
+* Output:           
+*
+* Return:          
+*
+******************************************************************/
+static int
+ipmi_getdrivemap(void * intf, int b, int d, int f, int *bay, int *slot)
+{
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req = {0};
+    uint8_t data[8];
+
+    /* Get mapping of BDF to bay:slot */
+    req.msg.netfn = IPMI_DELL_OEM_NETFN;
+    req.msg.lun = 0;
+    req.msg.cmd = 0xD5;
+    req.msg.data_len = 8;
+    req.msg.data = data;
+
+    memset(data, 0, sizeof(data));
+    data[0] = 0x01;		// get
+    data[1] = 0x07;		// storage map
+    data[2] = 0x06;		// length lsb
+    data[3] = 0x00;		// length msb
+    data[4] = 0x00;		// offset lsb
+    data[5] = 0x00;		// offset msb
+    data[6] = b;		// bus
+    data[7] = (d << 3) + f;	// devfn
+
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+	printf(" Error issuing getdrivemap command, ");
+	if (rv < 0) printf("no response\n");
+	else printf("Completion Code 0x%02x %s\n", rv, decode_cc(0,rv));
+	return rv;
+    }
+
+    *bay = rsp[7];
+    *slot = rsp[8];
+    if (*bay == 0xFF || *slot == 0xFF)
+    {
+	lprintf(LOG_ERR, "Error could not get drive bay:slot mapping");
+	return -1;
+    }
+    return 0;
+}
+
+/*****************************************************************
+* Function Name:    ipmi_setled_state
+*
+* Description:      This function updates the LED on the backplane
+* Input:            intf         - ipmi interface
+*		    bdf	 	 - PCI Address of drive
+*		    state	 - SES Flags state of drive
+* Output:           
+*
+* Return:          
+*
+******************************************************************/
+static int
+ipmi_setled_state (void * intf, int bayId, int slotId, int state)
+{
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req = {0};
+    uint8_t data[20];
+
+    /* Issue Drive Status Update to bay:slot */
+    req.msg.netfn = IPMI_DELL_OEM_NETFN;
+    req.msg.lun = 0;
+    req.msg.cmd = 0xD5;
+    req.msg.data_len = 20;
+    req.msg.data = data;
+
+    memset(data, 0, sizeof(data));
+    data[0] = 0x00;		// set
+    data[1] = 0x04;		// set drive status
+    data[2] = 0x0e;		// length lsb
+    data[3] = 0x00;		// length msb
+    data[4] = 0x00;		// offset lsb
+    data[5] = 0x00;		// offset msb
+    data[6] = 0x0e;		// length lsb
+    data[7] = 0x00;		// length msb
+    data[8] = bayId;		// bayid
+    data[9] = slotId;		// slotid
+    data[10] = state & 0xff;	// state LSB
+    data[11] = state >> 8;	// state MSB;
+
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+	printf(" Error issuing setled command, ");
+	if (rv < 0) printf("no response\n");
+	else printf("Completion Code 0x%02x %s\n", rv, decode_cc(0,rv));
+	return rv;
+    }
+
+    return 0;
+}
+
+int ipmi_delloem_getled_state (void * intf, uint8_t *state)
+{
+    uint8_t rsp[IPMI_RSPBUF_SIZE]; int rsp_len, rv;
+    struct ipmi_rq req = {0};
+    uint8_t data[2];
+    uint8_t led_state = 0;
+
+    req.msg.netfn = IPMI_DELL_OEM_NETFN;
+    req.msg.lun = 0;
+    req.msg.cmd = GET_CHASSIS_LED_STATE;
+    req.msg.data_len = 0;
+    req.msg.data = data;
+
+    rv = ipmi_sendrecv(&req, &rsp[0], &rsp_len);
+    if (rv) {
+	printf(" Error issuing getled command, ");
+	if (rv < 0) printf("no response\n");
+	else printf("Completion Code 0x%02x %s\n", rv, decode_cc(0,rv));
+    } else {
+        led_state = rsp[0];  
+    }
+    *state = led_state;
+    return rv;
+}
+
+/*****************************************************************
+* Function Name:    ipmi_getsesmask
+*
+* Description:      This function calculates bits in SES drive update
+* Return:           Mask set with bits for SES backplane update
+*
+******************************************************************/
+static int ipmi_getsesmask(int  argc, char **argv)
+{
+	int mask = 0;
+	//int idx;
+	
+	while (current_arg < argc) {
+		if (!strcmp(argv[current_arg], "present"))
+			mask |= (1L << 0);
+		if (!strcmp(argv[current_arg], "online"))
+			mask |= (1L << 1);
+		if (!strcmp(argv[current_arg], "hotspare"))
+			mask |= (1L << 2);
+		if (!strcmp(argv[current_arg], "identify"))
+			mask |= (1L << 3);
+		if (!strcmp(argv[current_arg], "rebuilding"))
+			mask |= (1L << 4);
+		if (!strcmp(argv[current_arg], "fault"))
+			mask |= (1L << 5);
+		if (!strcmp(argv[current_arg], "predict"))
+			mask |= (1L << 6);
+		if (!strcmp(argv[current_arg], "critical"))
+			mask |= (1L << 9);
+		if (!strcmp(argv[current_arg], "failed"))
+			mask |= (1L << 10);
+		current_arg++;
+	}
+	return mask;
+}
+
+/*****************************************************************
+* Function Name:       ipmi_delloem_setled_main
+*
+* Description:         This function processes the delloem setled command
+* Input:               intf    - ipmi interface
+                       argc    - no of arguments
+                       argv    - argument string array
+* Output:        
+*
+* Return:              return code     0 - success
+*                         -1 - failure
+*
+******************************************************************/
+static int
+ipmi_delloem_setled_main(void * intf, int  argc, char ** argv)
+{
+    int rc = -1;
+    int b,d,f, mask;
+    int bayId, slotId;
+
+    bayId = 0xFF;
+    slotId = 0xFF;
+
+    current_arg++;
+    if (argc < current_arg) 
+    {
+        usage();
+        return rc;
+    }
+
+    /* ipmitool delloem setled info*/
+    if (argc == 1 || strcmp(argv[current_arg], "help") == 0)
+    {
+        ipmi_setled_usage();
+	return 0;
+    }
+    CheckSetLEDSupport (intf);
+    if (!IsSetLEDSupported())
+    {
+        printf("'setled' is not supported on this system.\n");
+        return rc;
+    }
+    else if (sscanf(argv[current_arg], "%*x:%x:%x.%x", &b,&d,&f) == 3) {
+        /* We have bus/dev/function of drive */
+	current_arg++;
+    	ipmi_getdrivemap (intf, b, d, f, &bayId, &slotId);
+    }
+    else if (sscanf(argv[current_arg], "%x:%x.%x", &b,&d,&f) == 3) {
+        /* We have bus/dev/function of drive */
+	current_arg++;
+    }
+    else {
+	ipmi_setled_usage();
+	return -1;
+    }
+    /* Get mask of SES flags */	
+    mask = ipmi_getsesmask(argc, argv);
+
+    /* Get drive mapping */
+    if (ipmi_getdrivemap (intf, b, d, f, &bayId, &slotId))
+	return -1;
+
+    /* Set drive LEDs */
+    return ipmi_setled_state (intf, bayId, slotId, mask);
+}
+
+static int
+ipmi_delloem_getled_main(void * intf, int  argc, char ** argv)
+{
+    int rc = 0;
+    uint8_t state;
+
+    if (argc == 1 || strncmp(argv[0], "help\0", 5) == 0) 
+    {
+        ipmi_delloem_getled_usage();
+	return(0);
+    } else {
+	rc = ipmi_delloem_getled_state (intf, &state);
+	if (rc != 0) printf("getled_state error %d\n",rc);
+	else {
+	   if (state == 0x01) 
+	        printf("Chassis ID LED Status = ON\n");
+	   else printf("Chassis ID LED Status = off\n");
+	}
+    }
+    return (rc);
+}
+
+/*
+ * decode_sensor_dell
+ * inputs:
+ *    sdr     = the SDR buffer
+ *    reading = the 3 or 4 bytes of data from GetSensorReading
+ *    pstring = points to the output string buffer
+ *    slen    = size of the output buffer
+ * outputs:
+ *    rv     = 0 if this sensor was successfully interpreted here,
+ *             non-zero otherwise, to use default interpretations.
+ *    pstring = contains the sensor reading interpretation string (if rv==0)
+ */
+int decode_sensor_dell(uchar *sdr,uchar *reading,char *pstring, int slen)
+{
+   int rv = -1;
+   uchar stype, evtype;
+
+   if (sdr == NULL || reading == NULL) return(rv);
+   if (pstring == NULL || slen == 0) return(rv);
+   /* sdr[3] is SDR type: 1=full, 2=compact, 0xC0=oem */
+   if (sdr[3] != 0x02) return(rv);  /*return if not compact SDR */
+   stype = sdr[12];  /*sensor type*/
+   evtype = sdr[13];  /*event type */
+   if (stype == 0x02) {  /* Discrete Voltage */
+      /* Dell Discrete Voltage is opposite from normal */
+      if (evtype == 0x03) {   /*oem interpretation */
+	 if (reading[2] & 0x01) strncpy(pstring,"OK",slen); 
+	 else      strncpy(pstring,"Exceeded",slen); /*LimitExceeded*/
+         rv = 0;
+      }
+   }
+   return(rv);
+}
+
+#define BIT(x)		(1 << x)
+#define	SIZE_OF_DESC	128
+
+char * get_dell_evt_desc(uchar *sel_rec)
+{
+	struct sel_event_record * rec = (struct sel_event_record *)sel_rec;
+	int data1, data2, data3;
+	int code;
+	char *desc = NULL;
+	
+	unsigned char count;
+	unsigned char node;
+	//unsigned char num;
+	unsigned char dimmNum;
+	unsigned char dimmsPerNode;
+	char          dimmStr[32];
+	//char          cardStr[32];
+	//char          numStr[32];
+	char          tmpdesc[SIZE_OF_DESC];
+	static char   rgdesc[SIZE_OF_DESC];
+	char*         str;
+	unsigned char incr = 0;
+	unsigned char i    = 0;
+	//unsigned char postCode;
+	// struct ipmi_rs *rsp;
+	// struct ipmi_rq req;
+	char tmpData;
+	int version;
+        // uint8_t devid[20]; /*usually 16 bytes*/
+        uint8_t iver;
+	// int rv;
+
+	data1 = rec->sel_type.standard_type.event_data[0];
+	data2 = rec->sel_type.standard_type.event_data[1];
+	data3 = rec->sel_type.standard_type.event_data[2];
+	if ( (rec->sel_type.standard_type.event_type == 0x0B) || 
+		(rec->sel_type.standard_type.event_type == 0x6F)  || 
+		(rec->sel_type.standard_type.event_type == 0x07)) 
+		{
+		code = rec->sel_type.standard_type.sensor_type;
+		/* BDF or Slot */
+		desc = rgdesc;
+		memset(desc,0,SIZE_OF_DESC);
+		switch (code) {
+			case 0x07:
+				if( ((data1 & DATA_BYTE2_SPECIFIED_MASK) == 0x80))
+				{
+					if((data1 & 0x0f) == 0x00) 
+						snprintf(desc,SIZE_OF_DESC,"CPU Internal Err | ");
+					if((data1 & 0x0f) == 0x06)
+					{
+						snprintf(desc,SIZE_OF_DESC,"CPU Protocol Err | ");
+					}
+					/* change bit location to a number */
+					for (count= 0; count < 8; count++)
+					{
+					  if (BIT(count)& data2)
+					  {
+					    count++;
+						if( ((data1 & 0x0f) == 0x06) && (rec->sel_type.standard_type.sensor_num == 0x0A)) 
+						    snprintf(desc,SIZE_OF_DESC,"FSB %d ",count);
+						else
+						    snprintf(desc,SIZE_OF_DESC,"CPU %d | APIC ID %d ",count,data3);
+					    break;
+					  }
+					}
+				}
+			break;
+			case 0x0C:
+				if ( (rec->sel_type.standard_type.event_type == 0x0B) && 
+						!(data1 & 0x03) ) 
+					{
+						if(data2 & 0x04)
+							strcpy(desc,"Memory is in Spare Mode");
+						else if(data2 & 0x02)
+							strcpy(desc,"Memory is in Raid Mode ");
+						else if(data2 & 0x01)
+							strcpy(desc,"Memory is in Mirror Mode ");
+						break;
+					}
+			case 0x10:				
+				get_devid_ver(NULL,NULL,&iver);
+		//		rv = ipmi_getdeviceid(devid,sizeof(devid),fdbg);
+		//		if (rv != 0) return NULL;
+				version = iver;
+				/* Memory DIMMS */
+				if( (data1 &  0x80) || (data1 & 0x20 ) )
+				{
+					if( (code == 0x0c) && (rec->sel_type.standard_type.event_type == 0x0B) )
+					{
+						if((data1 & 0x0f) == 0x00) 
+						{
+							snprintf(desc,SIZE_OF_DESC," Redundancy Regained | ");
+						}
+						else if((data1 & 0x0f) == 0x01)
+						{
+							snprintf(desc,SIZE_OF_DESC,"Redundancy Lost | ");
+						}
+					}	
+					else if(code == 0x0c) 
+					{
+						if((data1 & 0x0f) == 0x00)
+						{
+							if(rec->sel_type.standard_type.sensor_num == 0x1C)
+							{
+								if((data1 &  0x80) && (data1 & 0x20 ))
+								{
+									count = 0;
+									snprintf(desc,SIZE_OF_DESC,"CRC Error on:");
+									for(i=0;i<4;i++)
+									{
+										if((BIT(i))&(data2))
+										{
+											if(count)
+											{
+												str = desc+strlen(desc);
+												*str++ = ',';
+												 str = '\0';
+						              			count = 0;
+											}
+											switch(i)
+											{
+												case 0: snprintf(tmpdesc,SIZE_OF_DESC,"South Bound Memory");
+														strcat(desc,tmpdesc);
+														count++;
+														break;
+												case 1:	snprintf(tmpdesc,SIZE_OF_DESC,"South Bound Config");
+														strcat(desc,tmpdesc);
+														count++;
+														break;
+												case 2: snprintf(tmpdesc,SIZE_OF_DESC,"North Bound memory");
+														strcat(desc,tmpdesc);
+														count++;
+														break;
+												case 3:	snprintf(tmpdesc,SIZE_OF_DESC,"North Bound memory-corr");
+														strcat(desc,tmpdesc);
+														count++;
+														break;
+												default:
+														break;
+											}
+										}
+									}
+									if(data3>=0x00 && data3<0xFF)
+									{
+										snprintf(tmpdesc,SIZE_OF_DESC,"|Failing_Channel:%d",data3);
+										strcat(desc,tmpdesc);
+									}
+								}
+								break;
+							}
+							snprintf(desc,SIZE_OF_DESC,"Correctable ECC | ");
+						}
+						else if((data1 & 0x0f) == 0x01) 
+						{
+							snprintf(desc,SIZE_OF_DESC,"UnCorrectable ECC | ");
+						}
+					} 
+					else if(code == 0x10)
+					{
+						if((data1 & 0x0f) == 0x00) 
+							snprintf(desc,SIZE_OF_DESC,"Corr Memory Log Dissabled | ");
+					}
+				} 
+				else
+				{
+					if(code == 0x12) 
+					{
+						if((data1 & 0x0f) == 0x02) 
+							snprintf(desc,SIZE_OF_DESC,"Unknown System Hardware Failure ");
+					}
+					if(code == 0x10)
+					{
+						if((data1 & 0x0f) == 0x03) 
+							snprintf(desc,SIZE_OF_DESC,"All Even Logging Dissabled");
+					}
+				}
+				if(data1 & 0x80 ) 
+				{
+					if(((data2 >> 4) != 0x0f) && ((data2 >> 4) < 0x08))
+					{
+						tmpData = 	('A'+ (data2 >> 4));
+						if( (code == 0x0c) && (rec->sel_type.standard_type.event_type == 0x0B) )
+						{
+							snprintf(tmpdesc, SIZE_OF_DESC, "Bad Card %c", tmpData);								
+						}
+						else
+						{
+							snprintf(tmpdesc, SIZE_OF_DESC, "Card %c", tmpData);
+						}
+						strcat(desc, tmpdesc);
+					}
+					if (0x0F != (data2 & 0x0f)) 
+					{
+						if(0x51  == version)
+						{
+							snprintf(tmpdesc, SIZE_OF_DESC, "Bank %d", ((data2 & 0x0f)+1));	
+							strcat(desc, tmpdesc);
+						}
+						else 
+						{
+							incr = (data2 & 0x0f) << 3;
+						}
+					}
+					
+				}
+				if(data1 & 0x20 )
+				{
+					if(0x51  == version) 
+					{
+						snprintf(tmpdesc, SIZE_OF_DESC, "DIMM %s", ('A'+ data3));
+						strcat(desc, tmpdesc);						
+					} 
+					else if( ((data2 >> 4) > 0x07) && ((data2 >> 4) != 0x0F)) 
+					{
+						strcpy(dimmStr, " DIMM_");
+						str = desc+strlen(desc);
+						dimmsPerNode = 4;
+						if( (data2 >> 4) == 0x09) dimmsPerNode = 6;
+						else if( (data2 >> 4) == 0x0A) dimmsPerNode = 8;
+						else if( (data2 >> 4) == 0x0B) dimmsPerNode = 9;
+						else if( (data2 >> 4) == 0x0C) dimmsPerNode = 12;
+						else if( (data2 >> 4) == 0x0D) dimmsPerNode = 24;	
+						else if( (data2 >> 4) == 0x0E) dimmsPerNode = 3;							
+						count = 0;
+				        for (i = 0; i < 8; i++)
+				        {
+				          if (BIT(i) & data3)
+				          {
+				            if (count)
+				            {
+				              *str++ = ',';
+				              count = 0;
+				            }
+				            node = (incr + i)/dimmsPerNode;
+				            dimmNum = ((incr + i)%dimmsPerNode)+1;
+				            dimmStr[5] = node + 'A';
+				            sprintf(tmpdesc,"%d",dimmNum);
+				            dimmStr[6] = tmpdesc[0];
+							dimmStr[7] = '\0'; 
+							strcat(str,dimmStr);
+				            count++;
+				          }
+				        }
+					} 
+					else 
+					{
+				        strcpy(dimmStr, " DIMM");
+						str = desc+strlen(desc);
+				        count = 0;
+				        for (i = 0; i < 8; i++)
+				        {
+				          if (BIT(i) & data3)
+				          {
+				            // check if more than one DIMM, if so add a comma to the string.
+				            if (count)
+				            {
+				              *str++ = ',';
+				              count = 0;
+				            }
+				            sprintf(tmpdesc,"%d",(i + incr + 1));
+							dimmStr[4] = tmpdesc[0];
+							dimmStr[5] = '\0'; 
+				            strcat(str, dimmStr);
+				            count++;
+				          }
+				        }
+			        }
+				}
+			break;
+			case 0x20:
+				if(((data1 & 0x0f)== 0x00)&&((data1 & 0x80) && (data1 & 0x20)))
+				{
+					if((data2 > 0x00)&&(data2<0xFF))
+					{
+						//Add the code to display 194 entries.This sensor present only in ORCA
+						
+					}	
+					switch(data3)
+					{
+						case 0x01:
+							snprintf(desc,SIZE_OF_DESC,"BIOS TXT Error");
+							break;
+						case 0x02:
+							snprintf(desc,SIZE_OF_DESC,"Processor/FIT TXT");
+							break;
+						case 0x03:
+							snprintf(desc,SIZE_OF_DESC,"BIOS ACM TXT Error");
+							break;
+						case 0x04:
+							snprintf(desc,SIZE_OF_DESC,"SINIT ACM TXT Error");
+							break;
+						case 0xff:
+							snprintf(desc,SIZE_OF_DESC,"Unrecognized TT Error12");
+							break;
+						default:
+							break;						
+					}
+				}
+			break;	
+			case 0x23:
+				
+				if(data1 == 0xC1)
+				{
+					if(data2 == 0x04)
+					{
+						snprintf(desc,SIZE_OF_DESC,"Hard Reset|Interrupt type None,SMS/OS Timer used at expiration");
+					}
+				}	
+				
+			break;
+			case 0x2B:
+				if(((data1 & 0x0f)== 0x02)&&((data1 & 0x80) && (data1 & 0x20)))
+				{
+					if(data2 == 0x02)
+					{
+						if(data3 == 0x00)
+						{
+							snprintf(desc, SIZE_OF_DESC, "between BMC/iDRAC Firmware and other hardware");
+						}
+						else if(data3 == 0x01)
+						{
+							snprintf(desc, SIZE_OF_DESC, "between BMC/iDRAC Firmware and CPU");
+						}
+					}
+				}
+			break;	
+			
+			case 0xC1:
+				if(rec->sel_type.standard_type.sensor_num == 0x25)
+				{
+					if((data1 & 0x0f) == 0x01)
+					{
+						snprintf(desc, SIZE_OF_DESC, "Failed to program Virtual Mac Address");
+						if((data1 & 0x80)&&(data1 & 0x20))
+						{
+							snprintf(tmpdesc, SIZE_OF_DESC, "PCI %.2x:%.2x.%x",
+							data3 &0x7f, (data2 >> 3) & 0x1F, 
+							data2 & 0x7);
+						}
+					}
+					else if((data1 & 0x0f) == 0x02)
+					{
+						snprintf(desc, SIZE_OF_DESC, "Device option ROM failed to support link tuning or flex address");
+						if((data1 & 0x80)&&(data1 & 0x20))
+						{
+							//Add Mezzanine code here.DELLOEM SEL displayed unknown event
+						}
+					}
+					else if((data1 & 0x0f) == 0x03)
+					{
+						snprintf(desc, SIZE_OF_DESC, "Failed to get link tuning or flex address data from BMC/iDRAC");
+					}
+					strcat(desc,tmpdesc);
+				}
+			break;	
+			case 0x13:
+			case 0xC2:
+			case 0xC3:	
+				if(rec->sel_type.standard_type.sensor_num == 0x29)
+				{
+					if(((data1 & 0x0f)== 0x02)&&((data1 & 0x80) && (data1 & 0x20)))
+					{
+					#if 1 /*This sensor is not implemented in iDRAC code*/
+						snprintf(tmpdesc, SIZE_OF_DESC, "Partner-(LinkId:%d,AgentId:%d)|",(data2 & 0xC0),(data2 & 0x30));
+						strcat(desc,tmpdesc);
+						snprintf(tmpdesc, SIZE_OF_DESC, "ReportingAgent(LinkId:%d,AgentId:%d)|",(data2 & 0x0C),(data2 & 0x03));
+						strcat(desc,tmpdesc);
+						if((data3 & 0xFC) == 0x00)
+						{
+							snprintf(tmpdesc, SIZE_OF_DESC, "LinkWidthDegraded|");
+							strcat(desc,tmpdesc);
+						}
+						if(BIT(1)& data3)
+						{
+							snprintf(tmpdesc,SIZE_OF_DESC,"PA_Type:IOH|");
+						}
+						else
+						{
+							snprintf(tmpdesc,SIZE_OF_DESC,"PA-Type:CPU|");
+						}
+						strcat(desc,tmpdesc);
+						if(BIT(0)& data3)
+						{
+							snprintf(tmpdesc,SIZE_OF_DESC,"RA-Type:IOH");
+						}
+						else
+						{
+							snprintf(tmpdesc,SIZE_OF_DESC,"RA-Type:CPU");
+						}
+						strcat(desc,tmpdesc);
+					#endif	
+					}
+				}
+				else
+				{
+					
+					if((data1 & 0x0f) == 0x02) 
+					{
+						sprintf(desc,"%s","IO channel Check NMI");
+					}
+					else 
+					{
+						if((data1 & 0x0f) == 0x00)
+						{
+							snprintf(desc, SIZE_OF_DESC, "%s","PCIe Error |"); 
+						}
+						else if((data1 & 0x0f) == 0x01) 
+						{
+							snprintf(desc, SIZE_OF_DESC, "%s","I/O Error |"); 
+						}
+						else if((data1 & 0x0f) == 0x04) 
+						{
+							snprintf(desc, SIZE_OF_DESC, "%s","PCI PERR |"); 
+						} 
+						else if((data1 & 0x0f) == 0x05)
+						{
+							snprintf(desc, SIZE_OF_DESC, "%s","PCI SERR |");
+						} 
+						else 
+						{
+							snprintf(desc, SIZE_OF_DESC, "%s"," ");
+						}
+						if (data3 & 0x80)
+							snprintf(tmpdesc, SIZE_OF_DESC, "Slot %d", data3 & 0x7f);
+						else
+							snprintf(tmpdesc, SIZE_OF_DESC, "PCI %.2x:%.2x.%x",
+							data3 &0x7f, (data2 >> 3) & 0x1F, 
+							data2 & 0x7);
+						strcat(desc,tmpdesc);
+					}
+				}
+			break;	
+			case 0x0F:	
+				if(((data1 & 0x0f)== 0x0F)&&(data1 & 0x80))
+				{
+					switch(data2)
+					{
+						case 0x80:
+							snprintf(desc, SIZE_OF_DESC, "No memory is detected.");break;
+						case 0x81:	
+							snprintf(desc,SIZE_OF_DESC, "Memory is detected but is not configurable.");break;
+						case 0x82:
+							snprintf(desc, SIZE_OF_DESC, "Memory is configured but not usable.");break;
+						case 0x83:
+							snprintf(desc, SIZE_OF_DESC, "System BIOS shadow failed.");break;
+						case 0x84:	
+							snprintf(desc, SIZE_OF_DESC, "CMOS failed.");break;
+						case 0x85:	
+							snprintf(desc, SIZE_OF_DESC, "DMA controller failed.");break;
+						case 0x86:	
+							snprintf(desc, SIZE_OF_DESC, "Interrupt controller failed.");break;
+						case 0x87:
+							snprintf(desc, SIZE_OF_DESC, "Timer refresh failed.");break;
+						case 0x88:
+							snprintf(desc, SIZE_OF_DESC, "Programmable interval timer error.");break;
+						case 0x89:
+							snprintf(desc, SIZE_OF_DESC, "Parity error.");break;
+						case 0x8A:
+							snprintf(desc, SIZE_OF_DESC, "SIO failed.");break;
+						case 0x8B:	
+							snprintf(desc, SIZE_OF_DESC, "Keyboard controller failed.");break;
+						case 0x8C:	
+							snprintf(desc, SIZE_OF_DESC, "System management interrupt initialization failed.");break;
+						case 0x8D:	
+							snprintf(desc, SIZE_OF_DESC, "TXT-SX Error.");break;
+						case 0xC0:
+							snprintf(desc, SIZE_OF_DESC, "Shutdown test failed.");break;
+						case 0xC1:	
+							snprintf(desc, SIZE_OF_DESC, "BIOS POST memory test failed.");break;
+						case 0xC2:	
+							snprintf(desc, SIZE_OF_DESC, "RAC configuration failed.");break;
+						case 0xC3:	
+							snprintf(desc, SIZE_OF_DESC, "CPU configuration failed.");break;
+						case 0xC4:	
+							snprintf(desc, SIZE_OF_DESC, "Incorrect memory configuration.");break;
+						case 0xFE:	
+							snprintf(desc, SIZE_OF_DESC, "General failure after video.");
+							break;
+					}
+				}
+			break;
+			
+			default:
+			break;				
+		} 
+	}
+	else
+	{
+		code = rec->sel_type.standard_type.event_type;
+	}
+	return desc;
+}
+
+/* 
+ * decode_sel_dell
+ * inputs:
+ *    evt    = the 16-byte IPMI SEL event
+ *    outbuf = points to the output string buffer
+ *    outsz  = size of the output buffer
+ * outputs: 
+ *    rv     = 0 if this event was successfully interpreted here,
+ *             non-zero otherwise, to use default interpretations.
+ *    outbuf = will contain the interpreted event text string (if rv==0)
+ */
+int decode_sel_dell(uint8_t *evt, char *outbuf, int outsz, char fdesc, 
+			char fdbg)
+{
+   int rv = -1;
+   uint16_t id, genid;
+   uint8_t rectype;
+   uint32_t timestamp;
+   char *type_str = NULL;
+   char *gstr = NULL;
+   char *pstr = NULL;
+   int sevid;
+   uchar stype, snum;
+
+   fdebug = fdbg;
+   sevid = SEV_INFO;
+   id = evt[0] + (evt[1] << 8);
+   rectype = evt[2];
+   timestamp = evt[3] + (evt[4] << 8) + (evt[5] << 16) + (evt[6] << 24);
+   genid = evt[7] | (evt[8] << 8);
+   stype = evt[10];
+   snum = evt[11];
+   gstr = "BMC ";
+   if (genid == 0x0033) gstr = "Bios";
+   type_str = "";
+   if (rectype == 0x02) type_str = get_sensor_type_desc(stype);
+
+#ifdef OTHER
+   /* evt[13] is data1/offset*/
+   if ( ((evt[13] & DATA_BYTE2_SPECIFIED_MASK) == 0x80) ||
+        ((evt[13] & DATA_BYTE3_SPECIFIED_MASK) == 0x20) ) {
+	      // if (evt[13] & DATA_BYTE2_SPECIFIED_MASK)
+	 	 // evt->data = rec->sel_type.standard_type.event_data[1];
+              pstr = get_dell_evt_desc(evt);
+    } else if (evt[13] == 0xC1) {
+        if (snum == 0x23) {
+              //     evt->data = rec->sel_type.standard_type.event_data[1];
+              pstr = get_dell_evt_desc(evt);
+	}
+    }    
+#endif
+   pstr = get_dell_evt_desc(evt);
+   if (pstr != NULL) rv = 0;
+
+   if (rv == 0) {
+	format_event(id,timestamp, sevid, genid, type_str,
+			snum,NULL,pstr,NULL,outbuf,outsz);
+   }
+   return rv;
+}
+
+#ifdef METACOMMAND
+int i_delloem(int argc, char **argv)
+#else
+#ifdef WIN32
+int __cdecl
+#else
+int
+#endif
+main(int argc, char **argv)
+#endif
+{
+   int rv = 0;
+   uchar devrec[16];
+   int c, i;
+   char *s1;
+
+   printf("%s ver %s\n", progname,progver);
+   set_loglevel(LOG_NOTICE);
+   argc_sav = argc;
+   argv_sav = argv;
+   parse_lan_options('V',"4",0);  /*default to admin priv*/
+
+   while ( (c = getopt( argc, argv,"m:s:xzEF:J:N:P:R:T:U:V:YZ:?")) != EOF )
+      switch(c) {
+          case 'm': /* specific IPMB MC, 3-byte address, e.g. "409600" */
+                    g_bus = htoi(&optarg[0]);  /*bus/channel*/
+                    g_sa  = htoi(&optarg[2]);  /*device slave address*/
+                    g_lun = htoi(&optarg[4]);  /*LUN*/
+                    g_addrtype = ADDR_IPMB;
+                    if (optarg[6] == 's') {
+                             g_addrtype = ADDR_SMI;  s1 = "SMI";
+                    } else { g_addrtype = ADDR_IPMB; s1 = "IPMB"; }
+                    ipmi_set_mc(g_bus,g_sa,g_lun,g_addrtype);
+                    printf("Use MC at %s bus=%x sa=%x lun=%x\n",
+                            s1,g_bus,g_sa,g_lun);
+                    break;
+          case 's': sdrfile = optarg; break;
+          case 'x': fdebug = 2; /* normal (dbglog if isol) */
+                    verbose = 1;
+                    break;
+          case 'z': fdebug = 3; /*full debug (for isol)*/
+                    verbose = 1;
+                    break;
+          case 'N':    /* nodename */
+          case 'U':    /* remote username */
+          case 'P':    /* remote password */
+          case 'R':    /* remote password */
+          case 'E':    /* get password from IPMI_PASSWORD environment var */
+          case 'F':    /* force driver type */
+          case 'T':    /* auth type */
+          case 'J':    /* cipher suite */
+          case 'V':    /* priv level */
+          case 'Y':    /* prompt for remote password */
+          case 'Z':    /* set local MC address */
+                parse_lan_options(c,optarg,fdebug);
+                break;
+          default:
+		usage();
+                rv = ERR_USAGE;
+                goto do_exit;
+                break;
+      }
+   rv = ipmi_getdeviceid(devrec,16,fdebug);
+   if (rv == 0) {
+      char ipmi_maj, ipmi_min;
+      ipmi_maj = devrec[4] & 0x0f;
+      ipmi_min = devrec[4] >> 4;
+      // vend_id = devrec[6] + (devrec[7] << 8) + (devrec[8] << 16);
+      // prod_id = devrec[9] + (devrec[10] << 8);
+      show_devid( devrec[2],  devrec[3], ipmi_maj, ipmi_min);
+   }
+   for (i = 0; i < optind; i++) { argv++; argc--; }
+
+   rv = ipmi_delloem_main(NULL, argc, argv);
+
+do_exit:
+   ipmi_close_();
+   return(rv);
+}
+/* end oem_dell.c */