summaryrefslogtreecommitdiff
path: root/lib/ipmi_delloem.c
diff options
context:
space:
mode:
Diffstat (limited to 'lib/ipmi_delloem.c')
-rw-r--r--lib/ipmi_delloem.c4225
1 files changed, 4225 insertions, 0 deletions
diff --git a/lib/ipmi_delloem.c b/lib/ipmi_delloem.c
new file mode 100644
index 0000000..e190cd4
--- /dev/null
+++ b/lib/ipmi_delloem.c
@@ -0,0 +1,4225 @@
+/*
+ * 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>
+#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>
+#include <time.h>
+
+#include <ipmitool/ipmi.h>
+#include <ipmitool/ipmi_intf.h>
+#include <ipmitool/helper.h>
+#include <ipmitool/log.h>
+#include <ipmitool/ipmi_sel.h>
+#include <ipmitool/ipmi_delloem.h>
+#include <ipmitool/ipmi_fru.h>
+#include <ipmitool/ipmi_sdr.h>
+#include <ipmitool/ipmi_mc.h>
+#include <ipmitool/ipmi_sensor.h>
+#include <ipmitool/ipmi_sel.h>
+#include <ipmitool/bswap.h>
+#include <ipmitool/ipmi_sdr.h>
+#include <ipmitool/ipmi_entity.h>
+#include <ipmitool/ipmi_fru.h>
+#include <ipmitool/ipmi_sensor.h>
+
+#define DELL_OEM_NETFN (uint8_t)(0x30)
+#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
+/* 11g Support Macros */
+#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 */
+#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."
+#define INVAILD_FAILOVER_MODE_SET "ERROR: Cannot set shared with failover loms when NIC is set to dedicated Mode."
+#define INVAILD_SHARED_MODE_SET_STRING "ERROR: Cannot set shared Mode for Blades."
+
+char AciveLOM_String [6] [10] = {
+ "None",
+ "LOM1",
+ "LOM2",
+ "LOM3",
+ "LOM4",
+ "dedicated"
+};
+/* 11g Support Strings for nic selection */
+char NIC_Selection_Mode_String [4] [50] = {
+ "shared",
+ "shared with failover lom2",
+ "dedicated",
+ "shared with Failover all loms"
+};
+
+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"
+};
+
+const struct vFlashstr vFlash_completion_code_vals[] = {
+ {0x00, "SUCCESS"},
+ {0x01, "NO_SD_CARD"},
+ {0x63, "UNKNOWN_ERROR"},
+ {0x00, NULL}
+};
+
+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;
+
+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(struct ipmi_intf *intf, int argc,
+ char **argv);
+int ipmi_lcd_get_platform_model_name(struct ipmi_intf *intf, char *lcdstring,
+ uint8_t max_length, uint8_t field_type);
+static int ipmi_idracvalidator_command(struct ipmi_intf *intf);
+static int ipmi_lcd_get_configure_command_wh(struct ipmi_intf *intf);
+static int ipmi_lcd_get_configure_command(struct ipmi_intf *intf,
+ uint8_t *command);
+static int ipmi_lcd_set_configure_command(struct ipmi_intf *intf, int command);
+static int ipmi_lcd_set_configure_command_wh(struct ipmi_intf *intf, uint32_t mode,
+ uint16_t lcdquallifier,uint8_t errordisp);
+static int ipmi_lcd_get_single_line_text(struct ipmi_intf *intf,
+ char *lcdstring, uint8_t max_length);
+static int ipmi_lcd_get_info_wh(struct ipmi_intf *intf);
+static int ipmi_lcd_get_info(struct ipmi_intf *intf);
+static int ipmi_lcd_get_status_val(struct ipmi_intf *intf,
+ LCD_STATUS *lcdstatus);
+static int IsLCDSupported();
+static void CheckLCDSupport(struct ipmi_intf *intf);
+static void ipmi_lcd_status_print(LCD_STATUS lcdstatus);
+static int ipmi_lcd_get_status(struct ipmi_intf *intf);
+static int ipmi_lcd_set_kvm(struct ipmi_intf *intf, char status);
+static int ipmi_lcd_set_lock(struct ipmi_intf *intf, char lock);
+static int ipmi_lcd_set_single_line_text(struct ipmi_intf *intf, char *text);
+static int ipmi_lcd_set_text(struct ipmi_intf *intf, char *text,
+ int line_number);
+static int ipmi_lcd_configure_wh(struct ipmi_intf *intf, uint32_t mode,
+ uint16_t lcdquallifier, uint8_t errordisp, int8_t line_number, char *text);
+static int ipmi_lcd_configure(struct ipmi_intf *intf, int command,
+ int8_t line_number, char *text);
+static void ipmi_lcd_usage(void);
+/* MAC Function prototypes */
+static int ipmi_delloem_mac_main(struct ipmi_intf *intf, int argc, char **argv);
+static void InitEmbeddedNICMacAddressValues();
+static int ipmi_macinfo_drac_idrac_virtual_mac(struct ipmi_intf *intf,
+ uint8_t NicNum);
+static int ipmi_macinfo_drac_idrac_mac(struct ipmi_intf *intf,uint8_t NicNum);
+static int ipmi_macinfo_10g(struct ipmi_intf *intf, uint8_t NicNum);
+static int ipmi_macinfo_11g(struct ipmi_intf *intf, uint8_t NicNum);
+static int ipmi_macinfo(struct ipmi_intf *intf, uint8_t NicNum);
+static void ipmi_mac_usage(void);
+/* LAN Function prototypes */
+static int ipmi_delloem_lan_main(struct ipmi_intf *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(struct ipmi_intf *intf,
+ uint8_t nic_selection);
+static int ipmi_lan_get_nic_selection(struct ipmi_intf *intf);
+static int ipmi_lan_get_active_nic(struct ipmi_intf *intf);
+static void ipmi_lan_usage(void);
+static int ipmi_lan_set_nic_selection_12g(struct ipmi_intf *intf,
+ uint8_t *nic_selection);
+/* Power monitor Function prototypes */
+static int ipmi_delloem_powermonitor_main(struct ipmi_intf *intf, int argc,
+ char **argv);
+static void ipmi_time_to_str(time_t rawTime, char *strTime);
+static int ipmi_get_sensor_reading(struct ipmi_intf *intf,
+ unsigned char sensorNumber, SensorReadingType *pSensorReadingData);
+static int ipmi_get_power_capstatus_command(struct ipmi_intf *intf);
+static int ipmi_set_power_capstatus_command(struct ipmi_intf *intf,
+ uint8_t val);
+static int ipmi_powermgmt(struct ipmi_intf *intf);
+static int ipmi_powermgmt_clear(struct ipmi_intf *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(struct ipmi_intf *intf, uint8_t unit);
+static int ipmi_get_power_consumption_data(struct ipmi_intf *intf, uint8_t unit);
+static int ipmi_get_instan_power_consmpt_data(struct ipmi_intf *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(struct ipmi_intf *intf,
+ uint8_t unit);
+static int ipmi_get_avgpower_consmpt_history(struct ipmi_intf *intf,
+ IPMI_AVGPOWER_CONSUMP_HISTORY *pavgpower);
+static int ipmi_get_peakpower_consmpt_history(struct ipmi_intf *intf,
+ IPMI_POWER_CONSUMP_HISTORY *pstPeakpower);
+static int ipmi_get_minpower_consmpt_history(struct ipmi_intf *intf,
+ IPMI_POWER_CONSUMP_HISTORY *pstMinpower);
+static int ipmi_print_power_consmpt_history(struct ipmi_intf *intf, int unit);
+static int ipmi_get_power_cap(struct ipmi_intf *intf,
+ IPMI_POWER_CAP *ipmipowercap);
+static int ipmi_print_power_cap(struct ipmi_intf *intf, uint8_t unit);
+static int ipmi_set_power_cap(struct ipmi_intf *intf, int unit, int val);
+static void ipmi_powermonitor_usage(void);
+/* vFlash Function prototypes */
+static int ipmi_delloem_vFlash_main(struct ipmi_intf *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(struct ipmi_intf *intf);
+static int ipmi_delloem_vFlash_process(struct ipmi_intf *intf, int current_arg,
+ char **argv);
+static void ipmi_vFlash_usage(void);
+/* LED Function prototypes */
+static int ipmi_getsesmask(int, char **argv);
+static void CheckSetLEDSupport(struct ipmi_intf *intf);
+static int IsSetLEDSupported(void);
+static void ipmi_setled_usage(void);
+static int ipmi_delloem_setled_main(struct ipmi_intf *intf, int argc,
+ char **argv);
+static int ipmi_setled_state(struct ipmi_intf *intf, int bayId, int slotId,
+ int state);
+static int ipmi_getdrivemap(struct ipmi_intf *intf, int b, int d, int f,
+ int *bayId, int *slotId);
+
+/* 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(struct ipmi_intf * intf, int argc, char ** argv)
+{
+ int rc = 0;
+ current_arg = 0;
+ if (argc == 0 || strncmp(argv[0], "help\0", 5) == 0) {
+ usage();
+ return 0;
+ }
+ if (0 ==strncmp(argv[current_arg], "lcd\0", 4)) {
+ ipmi_delloem_lcd_main(intf,argc,argv);
+ } else if (strncmp(argv[current_arg], "mac\0", 4) == 0) {
+ /* mac address*/
+ ipmi_delloem_mac_main(intf,argc,argv);
+ } else if (strncmp(argv[current_arg], "lan\0", 4) == 0) {
+ /* lan address*/
+ ipmi_delloem_lan_main(intf,argc,argv);
+ } else if (strncmp(argv[current_arg], "setled\0", 7) == 0) {
+ /* SetLED support */
+ ipmi_delloem_setled_main(intf,argc,argv);
+ } else if (strncmp(argv[current_arg], "powermonitor\0", 13) == 0) {
+ /*Powermanagement report processing*/
+ ipmi_delloem_powermonitor_main(intf,argc,argv);
+ } else if (strncmp(argv[current_arg], "vFlash\0", 7) == 0) {
+ /* vFlash Support */
+ ipmi_delloem_vFlash_main(intf,argc,argv);
+ } else {
+ usage();
+ return -1;
+ }
+ 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,
+" powermonitor");
+ lprintf(LOG_NOTICE,
+" vFlash");
+ 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(struct ipmi_intf * 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()) {
+ lprintf(LOG_ERR, "lcd is not supported on this system.");
+ 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);
+ } else if (strncmp(argv[current_arg], "set\0", 4) == 0) {
+ /* ipmitool delloem lcd set*/
+ 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;
+ }
+ if (str2uchar(argv[current_arg], &line_number) != 0) {
+ lprintf(LOG_ERR,
+ "Argument '%s' is either not a number or out of range.",
+ argv[current_arg]);
+ return (-1);
+ }
+ 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;
+}
+/* ipmi_lcd_get_platform_model_name - This function retrieves the platform model
+ * name, or any other parameter which stores data in the same format
+ *
+ * @intf: pointer to interface
+ * @lcdstring: hostname/platform model string(output)
+ * @max_length: length of the platform model string
+ * @field_type: either hostname/platform model
+ *
+ * returns: 0 => success, other value means error
+ */
+int
+ipmi_lcd_get_platform_model_name(struct ipmi_intf * intf, char* lcdstring,
+ uint8_t max_length, uint8_t field_type)
+{
+ uint8_t data[4];
+ int bytes_copied = 0;
+ int ii = 0;
+ int lcdstring_len = 0;
+ int rc = 0;
+ IPMI_DELL_LCD_STRING lcdstringblock;
+
+ for (ii = 0; ii < 4; ii++) {
+ int bytes_to_copy;
+ rc = ipmi_mc_getsysinfo(intf, field_type, ii, 0, sizeof(lcdstringblock),
+ &lcdstringblock);
+ if (rc < 0) {
+ lprintf(LOG_ERR, "Error getting platform model name");
+ break;
+ } else if (rc > 0) {
+ lprintf(LOG_ERR, "Error getting platform model name: %s",
+ val2str(rc, completion_code_vals));
+ break;
+ }
+ /* first block is different - 14 bytes*/
+ if (ii == 0) {
+ 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 rc;
+}
+/*
+ * 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(struct ipmi_intf * intf)
+{
+ int rc;
+ uint8_t data[11];
+ rc = ipmi_mc_getsysinfo(intf, IPMI_DELL_IDRAC_VALIDATOR, 2, 0, sizeof(data),
+ data);
+ if (rc < 0) {
+ /*lprintf(LOG_ERR, " Error getting IMC type"); */
+ return -1;
+ } else if (rc > 0) {
+ /*lprintf(LOG_ERR, " Error getting IMC type: %s",
+ val2str(rsp->ccode, completion_code_vals)); */
+ return -1;
+ }
+ /* Support the 11G Monolithic, modular, Maisy and Coaster */
+ if ((IMC_IDRAC_11G_MONOLITHIC == data[10])
+ || (IMC_IDRAC_11G_MODULAR == data[10])
+ || (IMC_MASER_LITE_BMC == data[10])
+ || (IMC_MASER_LITE_NU == data[10])) {
+ iDRAC_FLAG=IDRAC_11G;
+ } else if((IMC_IDRAC_12G_MONOLITHIC == data[10])
+ || (IMC_IDRAC_12G_MODULAR == data[10])) {
+ iDRAC_FLAG = IDRAC_12G;
+ } else {
+ iDRAC_FLAG = 0;
+ }
+ IMC_Type = data[10];
+ 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(struct ipmi_intf * intf)
+{
+ uint8_t data[4];
+ int rc;
+ rc = ipmi_mc_getsysinfo(intf, IPMI_DELL_LCD_CONFIG_SELECTOR, 0, 0,
+ sizeof(lcd_mode), &lcd_mode);
+ if (rc < 0) {
+ lprintf(LOG_ERR, "Error getting LCD configuration");
+ return -1;
+ } else if ((rc == 0xc1) || (rc == 0xcb)){
+ lprintf(LOG_ERR, "Error getting LCD configuration: "
+ "Command not supported on this system.");
+ } else if (rc > 0) {
+ lprintf(LOG_ERR, "Error getting LCD configuration: %s",
+ val2str(rc, completion_code_vals));
+ return -1;
+ }
+ 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(struct ipmi_intf * intf, uint8_t *command)
+{
+ uint8_t data[4];
+ int rc;
+ rc = ipmi_mc_getsysinfo(intf, IPMI_DELL_LCD_CONFIG_SELECTOR, 0, 0,
+ sizeof(data), data);
+ if (rc < 0) {
+ lprintf(LOG_ERR, "Error getting LCD configuration");
+ return -1;
+ } else if ((rc == 0xc1)||(rc == 0xcb)) {
+ lprintf(LOG_ERR, "Error getting LCD configuration: "
+ "Command not supported on this system.");
+ return -1;
+ } else if (rc > 0) {
+ lprintf(LOG_ERR, "Error getting LCD configuration: %s",
+ val2str(rc, completion_code_vals));
+ return -1;
+ }
+ /* rsp->data[0] is the rev */
+ *command = data[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(struct ipmi_intf * intf, int command)
+{
+ #define LSCC_DATA_LEN 2
+ uint8_t data[2];
+ int rc;
+ data[0] = IPMI_DELL_LCD_CONFIG_SELECTOR;
+ data[1] = command; /* command - custom, default, none */
+ rc = ipmi_mc_setsysinfo(intf, 2, data);
+ if (rc < 0) {
+ lprintf(LOG_ERR, "Error setting LCD configuration");
+ return -1;
+ } else if ((rc == 0xc1) || (rc == 0xcb)) {
+ lprintf(LOG_ERR, "Error setting LCD configuration: "
+ "Command not supported on this system.");
+ } else if (rc > 0) {
+ lprintf(LOG_ERR, "Error setting LCD configuration: %s",
+ val2str(rc, completion_code_vals));
+ return -1;
+ }
+ 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
+ * lcdquallifier - lcd quallifier id
+ * errordisp - error number
+ * Output:
+ * Return:
+ */
+static int
+ipmi_lcd_set_configure_command_wh(struct ipmi_intf * intf, uint32_t mode,
+ uint16_t lcdquallifier, uint8_t errordisp)
+{
+ #define LSCC_DATA_LEN 2
+ uint8_t data[13];
+ int rc;
+ ipmi_lcd_get_configure_command_wh(intf);
+ 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 (lcdquallifier != 0xFF) {
+ if(lcdquallifier == 0x01) {
+ data[5] = (lcd_mode.lcdquallifier) | 0x01; /* command - custom, default, none*/
+ } else if (lcdquallifier == 0x00) {
+ data[5] = (lcd_mode.lcdquallifier) & 0xFE; /* command - custom, default, none*/
+ } else if (lcdquallifier == 0x03) {
+ data[5] = (lcd_mode.lcdquallifier) | 0x02; /* command - custom, default, none*/
+ } else if (lcdquallifier == 0x02) {
+ data[5] = (lcd_mode.lcdquallifier) & 0xFD;
+ }
+ } else {
+ data[5] = lcd_mode.lcdquallifier;
+ }
+ if (errordisp != 0xFF) {
+ data[11] = errordisp;
+ } else {
+ data[11] = lcd_mode.error_display;
+ }
+ rc = ipmi_mc_setsysinfo(intf, 13, data);
+ if (rc < 0) {
+ lprintf(LOG_ERR, "Error setting LCD configuration");
+ return -1;
+ } else if ((rc == 0xc1) || (rc == 0xcb)) {
+ lprintf(LOG_ERR, "Error setting LCD configuration: "
+ "Command not supported on this system.");
+ } else if (rc > 0) {
+ lprintf(LOG_ERR, "Error setting LCD configuration: %s",
+ val2str(rc, completion_code_vals));
+ return -1;
+ }
+ 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(struct ipmi_intf * intf, char* lcdstring,
+ uint8_t max_length)
+{
+ IPMI_DELL_LCD_STRING lcdstringblock;
+ int lcdstring_len = 0;
+ int bytes_copied = 0;
+ int ii, rc;
+ for (ii = 0; ii < 4; ii++) {
+ int bytes_to_copy;
+ rc = ipmi_mc_getsysinfo(intf, IPMI_DELL_LCD_STRING_SELECTOR, ii, 0,
+ sizeof(lcdstringblock), &lcdstringblock);
+ if (rc < 0) {
+ lprintf(LOG_ERR, "Error getting text data");
+ return -1;
+ } else if (rc > 0) {
+ lprintf(LOG_ERR, "Error getting text data: %s",
+ val2str(rc, completion_code_vals));
+ return -1;
+ }
+ /* 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(struct ipmi_intf * intf)
+{
+ 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;
+ }
+ if (lcd_mode.lcdmode== IPMI_DELL_LCD_CONFIG_DEFAULT) {
+ char text[IPMI_DELL_LCD_STRING_LENGTH_MAX+1] = {0};
+ if (ipmi_lcd_get_platform_model_name(intf, text,
+ IPMI_DELL_LCD_STRING_LENGTH_MAX,
+ IPMI_DELL_PLATFORM_MODEL_NAME_SELECTOR) != 0) {
+ 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) {
+ printf(" Setting: User defined\n");
+ rc = ipmi_mc_getsysinfo(intf, IPMI_DELL_LCD_GET_CAPS_SELECTOR, 0, 0,
+ sizeof(lcd_caps), &lcd_caps);
+ if (rc < 0) {
+ lprintf(LOG_ERR, "Error getting LCD capabilities.");
+ return -1;
+ } else if ((rc == 0xc1) || (rc == 0xcb)) {
+ lprintf(LOG_ERR, "Error getting LCD capabilities: "
+ "Command not supported on this system.");
+ } else if (rc > 0) {
+ lprintf(LOG_ERR, "Error getting LCD capabilities: %s",
+ val2str(rc, completion_code_vals));
+ return -1;
+ }
+ 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_ASSET_TAG) {
+ printf(" Setting: Asset Tag\n");
+ } else if (lcd_mode.lcdmode == IPMI_DELL_LCD_AMBEINT_TEMP) {
+ printf(" Setting: Ambient Temp\n");
+ if (lcd_mode.lcdquallifier & 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.lcdquallifier & 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(struct ipmi_intf * intf)
+{
+ 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;
+ }
+ if (command == IPMI_DELL_LCD_CONFIG_DEFAULT) {
+ memset(lcdstring,0,IPMI_DELL_LCD_STRING_LENGTH_MAX+1);
+ if (ipmi_lcd_get_platform_model_name(intf, lcdstring,
+ IPMI_DELL_LCD_STRING_LENGTH_MAX,
+ IPMI_DELL_PLATFORM_MODEL_NAME_SELECTOR) != 0) {
+ return (-1);
+ }
+ 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) {
+ printf(" Setting: custom\n");
+ rc = ipmi_mc_getsysinfo(intf, IPMI_DELL_LCD_GET_CAPS_SELECTOR, 0, 0,
+ sizeof(lcd_caps), &lcd_caps);
+ if (rc < 0) {
+ lprintf(LOG_ERR, "Error getting LCD capabilities.");
+ return -1;
+ } else if ((rc == 0xc1) || (rc == 0xcb)) {
+ lprintf(LOG_ERR, "Error getting LCD capabilities: "
+ "Command not supported on this system.");
+ } else if (rc > 0) {
+ lprintf(LOG_ERR, "Error getting LCD capabilities: %s",
+ val2str(rc, completion_code_vals));
+ return -1;
+ }
+ 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(struct ipmi_intf * intf, LCD_STATUS* lcdstatus)
+{
+ int rc;
+ rc = ipmi_mc_getsysinfo(intf, IPMI_DELL_LCD_STATUS_SELECTOR, 0, 0,
+ sizeof(*lcdstatus), lcdstatus);
+ if (rc < 0) {
+ lprintf(LOG_ERR, "Error getting LCD Status");
+ return -1;
+ } else if ((rc == 0xc1) || (rc == 0xcb)) {
+ lprintf(LOG_ERR, "Error getting LCD status: "
+ "Command not supported on this system.");
+ return -1;
+ } else if (rc > 0) {
+ lprintf(LOG_ERR, "Error getting LCD Status: %s",
+ val2str(rc, completion_code_vals));
+ return -1;
+ }
+ 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(struct ipmi_intf * intf)
+{
+ int rc;
+ LcdSupported = 0;
+ rc = ipmi_mc_getsysinfo(intf, IPMI_DELL_LCD_STATUS_SELECTOR, 0, 0, 0, NULL);
+ if (rc == 0) {
+ 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(struct ipmi_intf * 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(struct ipmi_intf * intf, char status)
+{
+ #define LSCC_DATA_LEN 2
+ LCD_STATUS lcdstatus;
+ int rc=0;
+ struct ipmi_rs * rsp = NULL;
+ 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 */
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error setting LCD status");
+ rc= -1;
+ } else if ((rsp->ccode == 0xc1) || (rsp->ccode == 0xcb)) {
+ lprintf(LOG_ERR, "Error getting LCD status: "
+ "Command not supported on this system.");
+ return -1;
+ } else if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, "Error setting LCD status: %s",
+ val2str(rsp->ccode, completion_code_vals));
+ rc= -1;
+ }
+ 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(struct ipmi_intf * intf, char lock)
+{
+ #define LSCC_DATA_LEN 2
+ LCD_STATUS lcdstatus;
+ int rc =0;
+ struct ipmi_rs * rsp = NULL;
+ 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 */
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error setting LCD status");
+ rc = -1;
+ } else if ((rsp->ccode == 0xc1) || (rsp->ccode == 0xcb)) {
+ lprintf(LOG_ERR, "Error getting LCD status: "
+ "Command not supported on this system.");
+ rc = -1;
+ } else if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, "Error setting LCD status: %s",
+ val2str(rsp->ccode, completion_code_vals));
+ rc= -1;
+ }
+ 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(struct ipmi_intf * intf, char * text)
+{
+ 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;
+ }
+ 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;
+ }
+ 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;
+ }
+ rc = ipmi_mc_setsysinfo(intf, 18, data);
+ if (rc < 0) {
+ lprintf(LOG_ERR, "Error setting text data");
+ rc = -1;
+ } else if (rc > 0) {
+ lprintf(LOG_ERR, "Error setting text data: %s",
+ val2str(rc, completion_code_vals));
+ rc = -1;
+ }
+ }
+ }
+ 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(struct ipmi_intf * intf, char * text, int line_number)
+{
+ int rc = 0;
+ IPMI_DELL_LCD_CAPS lcd_caps;
+ rc = ipmi_mc_getsysinfo(intf, IPMI_DELL_LCD_GET_CAPS_SELECTOR, 0, 0,
+ sizeof(lcd_caps), &lcd_caps);
+ if (rc < 0) {
+ lprintf(LOG_ERR, "Error getting LCD capabilities");
+ return -1;
+ } else if (rc > 0) {
+ lprintf(LOG_ERR, "Error getting LCD capabilities: %s",
+ val2str(rc, completion_code_vals));
+ return -1;
+ }
+ 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
+ * lcdquallifier- 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(struct ipmi_intf * intf, uint32_t mode,
+ uint16_t lcdquallifier, 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 ,lcdquallifier,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(struct ipmi_intf * 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-defined string.");
+ 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");
+ lprintf(LOG_NOTICE,
+" 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,
+"");
+ 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(struct ipmi_intf * intf, int argc, char ** argv)
+{
+ int rc = 0;
+ int currIdInt = -1;
+ current_arg++;
+ if (argc > 1 && strcmp(argv[current_arg], "help") == 0) {
+ ipmi_mac_usage();
+ return 0;
+ }
+ ipmi_idracvalidator_command(intf);
+ if (argc == 1) {
+ rc = ipmi_macinfo(intf, 0xff);
+ } else if (strncmp(argv[current_arg], "list\0", 5) == 0) {
+ rc = ipmi_macinfo(intf, 0xff);
+ } else if (strncmp(argv[current_arg], "get\0", 4) == 0) {
+ current_arg++;
+ if (argv[current_arg] == NULL) {
+ ipmi_mac_usage();
+ return -1;
+ }
+ if (str2int(argv[current_arg],&currIdInt) != 0) {
+ lprintf(LOG_ERR,
+ "Invalid NIC number. The NIC number should be between 0-8");
+ return -1;
+ }
+ if ((currIdInt > 8) || (currIdInt < 0)) {
+ lprintf(LOG_ERR,
+ "Invalid NIC number. The NIC number should be between 0-8");
+ return -1;
+ }
+ rc = ipmi_macinfo(intf, currIdInt);
+ } else {
+ ipmi_mac_usage();
+ }
+ return rc;
+}
+
+EmbeddedNICMacAddressType EmbeddedNICMacAddress;
+
+EmbeddedNICMacAddressType_10G EmbeddedNICMacAddress_10G;
+
+static void
+InitEmbeddedNICMacAddressValues()
+{
+ uint8_t i;
+ uint8_t j;
+ for (i = 0; i < MAX_LOM; i++) {
+ 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;
+ for (j = 0; j < MACADDRESSLENGH; j++) {
+ EmbeddedNICMacAddress.LOMMacAddress[i].MacAddressByte[j] = 0;
+ EmbeddedNICMacAddress_10G.MacAddress[i].MacAddressByte[j] = 0;
+ }
+ }
+}
+
+uint8_t UseVirtualMacAddress = 0;
+static int
+ipmi_macinfo_drac_idrac_virtual_mac(struct ipmi_intf* intf,uint8_t NicNum)
+{
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+ uint8_t msg_data[30];
+ uint8_t VirtualMacAddress [MACADDRESSLENGH];
+ uint8_t input_length=0;
+ uint8_t j;
+ uint8_t i;
+ if (NicNum != 0xff && NicNum != IDRAC_NIC_NUMBER) {
+ return 0;
+ }
+ UseVirtualMacAddress = 0;
+ input_length = 0;
+ msg_data[input_length++] = 1; /*Get*/
+
+ req.msg.netfn = 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;
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ return -1;
+ }
+ if (rsp->ccode > 0) {
+ return -1;
+ }
+ 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->data) + 1), MACADDRESSLENGH);
+ for (i = 0; i < MACADDRESSLENGH; i++) {
+ if (VirtualMacAddress[i] != 0) {
+ UseVirtualMacAddress = 1;
+ }
+ }
+ /* Get the Server Assigned MAC Addresss for 12g Only */
+ if (!UseVirtualMacAddress) {
+ memcpy(VirtualMacAddress, ((rsp->data) + 1 + MACADDRESSLENGH),
+ MACADDRESSLENGH);
+ for (i = 0; i < MACADDRESSLENGH; i++) {
+ if (VirtualMacAddress[i] != 0) {
+ UseVirtualMacAddress = 1;
+ }
+ }
+ }
+ } else {
+ memcpy(VirtualMacAddress, ((rsp->data) + VIRTUAL_MAC_OFFSET),
+ MACADDRESSLENGH);
+ for (i = 0; i < MACADDRESSLENGH; i++) {
+ if (VirtualMacAddress[i] != 0) {
+ UseVirtualMacAddress = 1;
+ }
+ }
+ }
+ if (UseVirtualMacAddress == 0) {
+ 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 ");
+ } else if ((IMC_MASER_LITE_BMC== IMC_Type)
+ || (IMC_MASER_LITE_NU== IMC_Type)) {
+ printf("\nBMC MAC Address ");
+ } else {
+ printf("\niDRAC6 MAC Address ");
+ }
+
+ for (j = 0; j < 5; j++) {
+ printf("%02x:", VirtualMacAddress[j]);
+ }
+ printf("%02x", VirtualMacAddress[j]);
+ printf("\n");
+ 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(struct ipmi_intf* intf,uint8_t NicNum)
+{
+ struct ipmi_rs * rsp;
+ 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 ((NicNum != 0xff && NicNum != IDRAC_NIC_NUMBER)
+ || UseVirtualMacAddress != 0) {
+ return 0;
+ }
+ 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;
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error in getting MAC Address");
+ return -1;
+ }
+ if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, "Error in getting MAC Address (%s)",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+ memcpy(iDRAC6MacAddressByte, ((rsp->data) + PARAM_REV_OFFSET),
+ MACADDRESSLENGH);
+
+ 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 ");
+ } else if ((IMC_MASER_LITE_BMC== IMC_Type)
+ || (IMC_MASER_LITE_NU== IMC_Type)) {
+ printf("\n\rBMC MAC Address ");
+ } else {
+ printf("\niDRAC6 MAC Address ");
+ }
+
+ for (j = 0; j < 5; j++) {
+ printf("%02x:", iDRAC6MacAddressByte[j]);
+ }
+ printf("%02x", iDRAC6MacAddressByte[j]);
+ printf("\n");
+ 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(struct ipmi_intf* intf, uint8_t NicNum)
+{
+ struct ipmi_rs * rsp;
+ 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 = IPMI_NETFN_APP;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_GET_SYS_INFO;
+ req.msg.data = msg_data;
+ req.msg.data_len = input_length;
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error in getting MAC Address");
+ return -1;
+ }
+ if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, "Error in getting MAC Address (%s)",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+ Total_No_NICs = (uint8_t)rsp->data[0 + PARAM_REV_OFFSET]; /* Byte 1: Total Number of Embedded NICs */
+ if (IDRAC_NIC_NUMBER != NicNum) {
+ if (0xff == NicNum) {
+ printf("\nSystem LOMs");
+ }
+ printf("\nNIC Number\tMAC Address\n");
+ memcpy(&EmbeddedNICMacAddress_10G,
+ ((rsp->data) + 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%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");
+ }
+ 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(struct ipmi_intf* intf, uint8_t NicNum)
+{
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+ uint8_t input_length = 0;
+ uint8_t i;
+ uint8_t j;
+ uint8_t len;
+ uint8_t loop_count;
+ uint8_t maxlen;
+ uint8_t msg_data[30];
+ uint8_t offset;
+ 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 = IPMI_NETFN_APP;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_GET_SYS_INFO;
+ req.msg.data = msg_data;
+ req.msg.data_len = input_length;
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error in getting MAC Address");
+ return -1;
+ }
+ if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, "Error in getting MAC Address (%s)",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+ len = 8; /*eigher 8 or 16 */
+ maxlen = (uint8_t)rsp->data[0 + PARAM_REV_OFFSET];
+ loop_count = maxlen / len;
+ if (IDRAC_NIC_NUMBER != NicNum) {
+ if (0xff == NicNum) {
+ printf("\nSystem LOMs");
+ }
+ printf("\nNIC Number\tMAC Address\t\tStatus\n");
+ /*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 = IPMI_NETFN_APP;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_GET_SYS_INFO;
+ req.msg.data = msg_data;
+ req.msg.data_len = input_length;
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error in getting MAC Address");
+ return -1;
+ }
+ if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, "Error in getting MAC Address (%s)",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+ memcpy(&(EmbeddedNICMacAddress.LOMMacAddress[i]),
+ ((rsp->data)+PARAM_REV_OFFSET), len);
+ if (LOM_MACTYPE_ETHERNET == EmbeddedNICMacAddress.LOMMacAddress[i].MacType) {
+ if ((0xff==NicNum)
+ || (NicNum == EmbeddedNICMacAddress.LOMMacAddress[i].NICNumber)) {
+ printf("\n%d",EmbeddedNICMacAddress.LOMMacAddress[i].NICNumber);
+ printf("\t\t");
+ for (j = 0; j < 5; j++) {
+ printf("%02x:",
+ EmbeddedNICMacAddress.LOMMacAddress[i].MacAddressByte[j]);
+ }
+ printf("%02x",
+ EmbeddedNICMacAddress.LOMMacAddress[i].MacAddressByte[j]);
+
+ if (LOM_ETHERNET_ENABLED
+ == EmbeddedNICMacAddress.LOMMacAddress[i].EthernetStatus) {
+ printf("\tEnabled");
+ } else {
+ printf("\tDisabled");
+ }
+ }
+ }
+ }
+ printf("\n");
+ }
+ 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(struct ipmi_intf* 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)
+ || (IMC_MASER_LITE_NU == IMC_Type || IMC_MASER_LITE_BMC== IMC_Type)) {
+ return ipmi_macinfo_11g(intf,NicNum);
+ } else {
+ lprintf(LOG_ERR, "Error in getting MAC Address : Not supported platform");
+ return (-1);
+ }
+}
+/*
+ * 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(struct ipmi_intf * 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()) {
+ lprintf(LOG_ERR, "lan is not supported on this system.");
+ 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) {
+ lprintf(LOG_ERR, INVAILD_FAILOVER_MODE_STRING);
+ return (-1);
+ } else if (INVAILD_FAILOVER_MODE_SETTINGS == nic_selection) {
+ lprintf(LOG_ERR, INVAILD_FAILOVER_MODE_SET);
+ return (-1);
+ } else if (INVAILD_SHARED_MODE == nic_selection) {
+ lprintf(LOG_ERR, INVAILD_SHARED_MODE_SET_STRING);
+ return (-1);
+ }
+ 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) {
+ lprintf(LOG_ERR, INVAILD_SHARED_MODE_SET_STRING);
+ return (-1);
+ }
+ 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(struct ipmi_intf* intf,int current_arg,
+ char ** argv, char *nic_set)
+{
+ /* First get the current settings. */
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+ int failover = 0;
+ int nic_selection_mode = 0;
+ uint8_t input_length = 0;
+ uint8_t msg_data[30];
+
+ input_length = 0;
+ req.msg.netfn = 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;
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error in getting nic selection");
+ return -1;
+ } else if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, "Error in getting nic selection (%s)",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+ nic_set[0] = rsp->data[0];
+ nic_set[1] = rsp->data[1];
+ if (argv[current_arg] != NULL
+ && strncmp(argv[current_arg], "dedicated\0", 10) == 0) {
+ nic_set[0] = 1;
+ nic_set[1] = 0;
+ return 0;
+ }
+ if (argv[current_arg] != NULL
+ && strncmp(argv[current_arg], "shared\0", 7) == 0) {
+ /* placeholder */
+ } else {
+ return INVALID;
+ }
+
+ current_arg++;
+ if (argv[current_arg] != NULL
+ && strncmp(argv[current_arg], "with\0", 5) == 0) {
+ /* placeholder */
+ } else {
+ return INVALID;
+ }
+
+ current_arg++;
+ if (argv[current_arg] != NULL
+ && strncmp(argv[current_arg], "failover\0", 9) == 0) {
+ failover = 1;
+ }
+ if (failover) {
+ current_arg++;
+ }
+ if (argv[current_arg] != NULL
+ && strncmp(argv[current_arg], "lom1\0", 5) == 0) {
+ 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 (argv[current_arg] != NULL
+ && strncmp(argv[current_arg], "lom2\0", 5) == 0) {
+ 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 (argv[current_arg] != NULL
+ && strncmp(argv[current_arg], "lom3\0", 5) == 0) {
+ 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 (argv[current_arg] != NULL
+ && strncmp(argv[current_arg], "lom4\0", 5) == 0) {
+ 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 && argv[current_arg] != NULL
+ && strncmp(argv[current_arg], "none\0", 5) == 0) {
+ 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 && argv[current_arg] != NULL
+ && strncmp(argv[current_arg], "all\0", 4) == 0) {
+ /* placeholder */
+ } else {
+ return INVALID;
+ }
+
+ current_arg++;
+ if (failover && argv[current_arg] != NULL
+ && strncmp(argv[current_arg], "loms\0", 5) == 0) {
+ 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)
+{
+ int nic_selection_mode = 0;
+ if (argv[current_arg] != NULL
+ && strncmp(argv[current_arg], "dedicated\0", 10) == 0) {
+ return DEDICATED;
+ }
+ if (argv[current_arg] != NULL
+ && strncmp(argv[current_arg], "shared\0", 7) == 0) {
+ if (argv[current_arg+1] == NULL) {
+ return SHARED;
+ }
+ }
+
+ current_arg++;
+ if (argv[current_arg] != NULL
+ && strncmp(argv[current_arg], "with\0", 5) == 0) {
+ /* place holder */
+ } else {
+ return INVALID;
+ }
+
+ current_arg++;
+ if (argv[current_arg] != NULL
+ && strncmp(argv[current_arg], "failover\0", 9) == 0) {
+ /* place holder */
+ } else {
+ return INVALID;
+ }
+
+ current_arg++;
+ if (argv[current_arg] != NULL
+ && strncmp(argv[current_arg], "lom2\0", 5) == 0) {
+ return SHARED_WITH_FAILOVER_LOM2;
+ } else if (argv[current_arg] != NULL
+ && strncmp(argv[current_arg], "all\0", 4) == 0) {
+ /* place holder */
+ } else {
+ return INVALID;
+ }
+
+ current_arg++;
+ if (argv[current_arg] != NULL
+ && strncmp(argv[current_arg], "loms\0", 5) == 0) {
+ return SHARED_WITH_FAILOVER_ALL_LOMS;
+ }
+ return INVALID;
+}
+
+static int
+ipmi_lan_set_nic_selection_12g(struct ipmi_intf * intf, uint8_t * nic_selection)
+{
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+ uint8_t input_length = 0;
+ uint8_t msg_data[30];
+
+ input_length = 0;
+ msg_data[input_length++] = nic_selection[0];
+ msg_data[input_length++] = nic_selection[1];
+ req.msg.netfn = 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;
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error in setting nic selection");
+ return -1;
+ } else if( (nic_selection[0] == 1)
+ && ((iDRAC_FLAG == IDRAC_12G) && (rsp->ccode == LICENSE_NOT_SUPPORTED))) {
+ /* Check license only for setting the dedicated nic. */
+ lprintf(LOG_ERR,
+ "FM001 : A required license is missing or expired");
+ return -1;
+ } else if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, "Error in setting nic selection (%s)",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+ printf("configured successfully");
+ return 0;
+}
+
+static int
+ipmi_lan_set_nic_selection(struct ipmi_intf * intf, uint8_t nic_selection)
+{
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+ uint8_t input_length = 0;
+ uint8_t msg_data[30];
+
+ input_length = 0;
+ msg_data[input_length++] = nic_selection;
+ req.msg.netfn = 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;
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error in setting nic selection");
+ return -1;
+ } else if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, "Error in setting nic selection (%s)",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+ printf("configured successfully");
+ return 0;
+}
+
+static int
+ipmi_lan_get_nic_selection(struct ipmi_intf * intf)
+{
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+ uint8_t input_length=0;
+ uint8_t msg_data[30];
+ uint8_t nic_selection=-1;
+ uint8_t nic_selection_failover = 0;
+
+ input_length = 0;
+ req.msg.netfn = 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;
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error in getting nic selection");
+ return -1;
+ } else if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, "Error in getting nic selection (%s)",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+ nic_selection = rsp->data[0];
+ if (iDRAC_FLAG == IDRAC_12G) {
+ nic_selection_failover = rsp->data[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)",
+ 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(struct ipmi_intf * intf)
+{
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+ uint8_t active_nic=0;
+ uint8_t current_lom =0;
+ uint8_t input_length=0;
+ uint8_t msg_data[30];
+
+ input_length = 0;
+ msg_data[input_length++] = 0; /* Get Status */
+ msg_data[input_length++] = 0; /* Reserved */
+ msg_data[input_length++] = 0; /* Reserved */
+ req.msg.netfn = 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;
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error in getting Active LOM Status");
+ return -1;
+ } else if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, "Error in getting Active LOM Status (%s)",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+ current_lom = rsp->data[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 = 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;
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error in getting Active LOM Status");
+ return -1;
+ } else if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, "Error in getting Active LOM Status (%s)",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+ active_nic = rsp->data[1];
+ if (current_lom < 6 && active_nic) {
+ printf("\n%s\n", AciveLOM_String[current_lom]);
+ } else {
+ printf("\n%s\n", AciveLOM_String[0]);
+ }
+ return 0;
+}
+
+static void
+ipmi_lan_usage(void)
+{
+ /* TODO:
+ * - rewrite
+ * - review
+ * - make it fit into 80 chars per line
+ * - this ``shared with Failover None).'' seems like a typo
+ */
+ 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 failover lom4,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 failover lom2,");
+ 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,
+" returns the current active NIC (dedicated, LOM1, LOM2, LOM3, LOM4).");
+ 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(struct ipmi_intf * 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;
+ }
+ if (str2int(argv[current_arg], &val) != 0) {
+ lprintf(LOG_ERR, "Given capacity value '%s' is invalid.",
+ argv[current_arg]);
+ return (-1);
+ }
+ 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) {
+ ipmi_set_power_capstatus_command(intf,1);
+ } else if (strncmp(argv[current_arg], "disablepowercap\0", 16) == 0) {
+ ipmi_set_power_capstatus_command(intf,0);
+ } else {
+ ipmi_powermonitor_usage();
+ return -1;
+ }
+ 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);
+}
+/*
+ * 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(struct ipmi_intf *intf, unsigned char sensorNumber,
+ SensorReadingType* pSensorReadingData)
+{
+ struct ipmi_rq req;
+ struct ipmi_rs * rsp;
+ int rc = 0;
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_SE;
+ req.msg.lun = 0;
+ req.msg.cmd = GET_SENSOR_READING;
+ req.msg.data = &sensorNumber;
+ req.msg.data_len = 1;
+ if (pSensorReadingData == NULL) {
+ return -1;
+ }
+ memset(pSensorReadingData, 0, sizeof(SensorReadingType));
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ return 1;
+ } else if (rsp->ccode > 0) {
+ return 1;
+ }
+ memcpy(pSensorReadingData, rsp->data, sizeof(SensorReadingType));
+ /* if there is an error transmitting ipmi command, return error */
+ if (rsp->ccode != 0) {
+ rc = 1;
+ }
+ /* if sensor messages are disabled, return error*/
+ if ((!(rsp->data[1]& 0xC0)) || ((rsp->data[1] & 0x20))) {
+ rc =1;
+ }
+ return rc;
+}
+/*
+ * 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(struct ipmi_intf * intf)
+{
+ struct ipmi_rs * rsp = NULL;
+ struct ipmi_rq req = {0};
+ uint8_t data[2];
+ req.msg.netfn = 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;
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error getting powercap status");
+ return -1;
+ } else if((iDRAC_FLAG == IDRAC_12G) && (rsp->ccode == LICENSE_NOT_SUPPORTED)) {
+ lprintf(LOG_ERR,
+ "FM001 : A required license is missing or expired");
+ return -1; /* Return Error as unlicensed */
+ } else if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, "Error getting powercap statusr: %s",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+ if (rsp->data[0] & 0x02) {
+ PowercapSetable_flag=1;
+ }
+ if (rsp->data[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(struct ipmi_intf * intf, uint8_t val)
+{
+ struct ipmi_rs * rsp = NULL;
+ 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 = 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;
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error setting powercap status");
+ return -1;
+ } else if ((iDRAC_FLAG == IDRAC_12G) && (rsp->ccode == LICENSE_NOT_SUPPORTED)) {
+ lprintf(LOG_ERR,
+ "FM001 : A required license is missing or expired");
+ return -1; /* return unlicensed Error code */
+ } else if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, "Error setting powercap statusr: %s",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+ return 0;
+}
+/*
+ * Function Name: ipmi_powermgmt
+ *
+ * Description: This function print the powermonitor details
+ * Input: intf - ipmi interface
+ * Output:
+ *
+ * Return:
+ */
+static int
+ipmi_powermgmt(struct ipmi_intf * intf)
+{
+ time_t now;
+ struct tm* tm;
+ struct ipmi_rs * rsp;
+ 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];
+
+ int ampReading;
+ int ampReadingRemainder;
+ int remainder;
+ int wattReading;
+
+ now = time(0);
+ tm = gmtime(&now);
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_STORAGE;
+ req.msg.lun = 0;
+ req.msg.cmd = IPMI_CMD_GET_SEL_TIME;
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error getting BMC time info.");
+ return -1;
+ }
+ if (rsp->ccode != 0) {
+ lprintf(LOG_ERR,
+ "Error getting power management information, return code %x",
+ rsp->ccode);
+ return -1;
+ }
+ bmctimeconvval=(uint32_t*)rsp->data;
+# if WORDS_BIGENDIAN
+ bmctimeconv=BSWAP_32(*bmctimeconvval);
+# else
+ bmctimeconv=*bmctimeconvval;
+# endif
+
+ /* get powermanagement info*/
+ req.msg.netfn = 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;
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error getting power management information.");
+ return -1;
+ }
+
+ if((iDRAC_FLAG == IDRAC_12G) && (rsp->ccode == LICENSE_NOT_SUPPORTED)) {
+ lprintf(LOG_ERR,
+ "FM001 : A required license is missing or expired");
+ return -1;
+ } else if ((rsp->ccode == 0xc1)||(rsp->ccode == 0xcb)) {
+ lprintf(LOG_ERR, "Error getting power management information: "
+ "Command not supported on this system.");
+ return -1;
+ }else if (rsp->ccode != 0) {
+ lprintf(LOG_ERR,
+ "Error getting power management information, return code %x",
+ rsp->ccode);
+ return -1;
+ }
+
+ pwrMonitorInfo = (IPMI_POWER_MONITOR*)rsp->data;
+# 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(struct ipmi_intf * intf, uint8_t clearValue)
+{
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req;
+ uint8_t clearType = 1;
+ uint8_t msg_data[3];
+ if (clearValue) {
+ clearType = 2;
+ }
+ /* clear powermanagement info*/
+ req.msg.netfn = 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;
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error clearing power values.");
+ return -1;
+ } else if ((iDRAC_FLAG == IDRAC_12G)
+ && (rsp->ccode == LICENSE_NOT_SUPPORTED)) {
+ lprintf(LOG_ERR,
+ "FM001 : A required license is missing or expired");
+ return -1;
+ } else if (rsp->ccode == 0xc1) {
+ lprintf(LOG_ERR,
+ "Error clearing power values, command not supported on this system.");
+ return -1;
+ } else if (rsp->ccode != 0) {
+ lprintf(LOG_ERR, "Error clearing power values: %s",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+ 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=(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= (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(struct ipmi_intf * intf,uint8_t unit)
+{
+ struct ipmi_rs * rsp = NULL;
+ struct ipmi_rq req = {0};
+ uint64_t peakpowerheadroombtuphr;
+ uint64_t instantpowerhearoom;
+
+ req.msg.netfn = DELL_OEM_NETFN;
+ req.msg.lun = 0;
+ req.msg.cmd = GET_PWR_HEADROOM_CMD;
+ req.msg.data_len = 0;
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error getting power headroom status");
+ return -1;
+ } else if ((iDRAC_FLAG == IDRAC_12G)
+ && (rsp->ccode == LICENSE_NOT_SUPPORTED)) {
+ lprintf(LOG_ERR,
+ "FM001 : A required license is missing or expired");
+ return -1;
+ } else if ((rsp->ccode == 0xc1) || (rsp->ccode == 0xcb)) {
+ lprintf(LOG_ERR, "Error getting power headroom status: "
+ "Command not supported on this system ");
+ return -1;
+ } else if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, "Error getting power headroom status: %s",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+ if (verbose > 1) {
+ /* need to look into */
+ printf("power headroom Data : %x %x %x %x ", rsp->data[0],
+ rsp->data[1], rsp->data[2], rsp->data[3]);
+ }
+ powerheadroom= *(( POWER_HEADROOM *)rsp->data);
+# if WORDS_BIGENDIAN
+ powerheadroom.instheadroom = BSWAP_16(powerheadroom.instheadroom);
+ powerheadroom.peakheadroom = BSWAP_16(powerheadroom.peakheadroom);
+# endif
+ printf("Headroom\n");
+ printf("Statistic Reading\n");
+ if (unit == btuphr) {
+ peakpowerheadroombtuphr = watt_to_btuphr_conversion(powerheadroom.peakheadroom);
+ instantpowerhearoom = watt_to_btuphr_conversion(powerheadroom.instheadroom);
+ printf("System Instantaneous Headroom : %lld BTU/hr\n",
+ instantpowerhearoom);
+ printf("System Peak Headroom : %lld BTU/hr\n",
+ peakpowerheadroombtuphr);
+ } else {
+ printf("System Instantaneous Headroom : %d W\n",
+ powerheadroom.instheadroom);
+ printf("System Peak Headroom : %d 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(struct ipmi_intf * intf,uint8_t unit)
+{
+ SensorReadingType sensorReadingData;
+
+ struct ipmi_rs * rsp=NULL;
+ struct sdr_record_list *sdr;
+ int readingbtuphr = 0;
+ int warning_threshbtuphr = 0;
+ int failure_threshbtuphr = 0;
+ int status = 0;
+ int sensor_number = 0;
+ sdr = ipmi_sdr_find_sdr_byid(intf, "System Level");
+ if (sdr == NULL) {
+ lprintf(LOG_ERR,
+ "Error : Can not access the System Level sensor data");
+ return -1;
+ }
+ sensor_number = sdr->record.common->keys.sensor_num;
+ ipmi_get_sensor_reading(intf,sensor_number,&sensorReadingData);
+ rsp = ipmi_sdr_get_sensor_thresholds(intf,
+ sdr->record.common->keys.sensor_num,
+ sdr->record.common->keys.owner_id,
+ sdr->record.common->keys.lun,
+ sdr->record.common->keys.channel);
+ if (rsp == NULL || rsp->ccode != 0) {
+ lprintf(LOG_ERR,
+ "Error : Can not access the System Level sensor data");
+ return -1;
+ }
+ readingbtuphr = sdr_convert_sensor_reading(sdr->record.full,
+ sensorReadingData.sensorReading);
+ warning_threshbtuphr = sdr_convert_sensor_reading(sdr->record.full,
+ rsp->data[4]);
+ failure_threshbtuphr = sdr_convert_sensor_reading(sdr->record.full,
+ rsp->data[5]);
+
+ printf("System Board System Level\n");
+ if (unit == btuphr) {
+ readingbtuphr = watt_to_btuphr_conversion(readingbtuphr);
+ warning_threshbtuphr = watt_to_btuphr_conversion(warning_threshbtuphr);
+ failure_threshbtuphr = watt_to_btuphr_conversion( failure_threshbtuphr);
+
+ printf("Reading : %d BTU/hr\n", readingbtuphr);
+ printf("Warning threshold : %d BTU/hr\n", warning_threshbtuphr);
+ printf("Failure threshold : %d BTU/hr\n", failure_threshbtuphr);
+ } else {
+ printf("Reading : %d W \n",readingbtuphr);
+ printf("Warning threshold : %d W \n",(warning_threshbtuphr));
+ printf("Failure threshold : %d W \n",(failure_threshbtuphr));
+ }
+ 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(struct ipmi_intf * intf,
+ IPMI_INST_POWER_CONSUMPTION_DATA * instpowerconsumptiondata)
+{
+ struct ipmi_rs * rsp;
+ struct ipmi_rq req={0};
+ uint8_t msg_data[2];
+ /*get instantaneous power consumption command*/
+ req.msg.netfn = 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;
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error getting instantaneous power consumption data .");
+ return -1;
+ } else if ((iDRAC_FLAG == IDRAC_12G)
+ && (rsp->ccode == LICENSE_NOT_SUPPORTED)) {
+ lprintf(LOG_ERR,
+ "FM001 : A required license is missing or expired");
+ return -1;
+ } else if ((rsp->ccode == 0xc1) || (rsp->ccode == 0xcb)) {
+ lprintf(LOG_ERR, "Error getting instantaneous power consumption data: "
+ "Command not supported on this system.");
+ return -1;
+ } else if (rsp->ccode != 0) {
+ lprintf(LOG_ERR, "Error getting instantaneous power consumption data: %s",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+ *instpowerconsumptiondata = *((IPMI_INST_POWER_CONSUMPTION_DATA *)(rsp->data));
+#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(struct ipmi_intf * intf, uint8_t unit)
+{
+ int rc = 0;
+ IPMI_INST_POWER_CONSUMPTION_DATA instpowerconsumptiondata = {0,0,0,0};
+ printf("\nPower consumption information\n");
+ rc = ipmi_get_power_consumption_data(intf, unit);
+ if (rc == (-1)) {
+ return rc;
+ }
+ rc = ipmi_get_instan_power_consmpt_data(intf, &instpowerconsumptiondata);
+ if (rc == (-1)) {
+ return rc;
+ }
+ ipmi_print_get_instan_power_Amps_data(instpowerconsumptiondata);
+ rc = ipmi_get_power_headroom_command(intf, unit);
+ if (rc == (-1)) {
+ 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(struct ipmi_intf * intf,
+ IPMI_AVGPOWER_CONSUMP_HISTORY * pavgpower)
+{
+ int rc;
+ uint8_t *rdata;
+ rc = ipmi_mc_getsysinfo(intf, 0xeb, 0, 0, sizeof(*pavgpower), pavgpower);
+ if (rc < 0) {
+ lprintf(LOG_ERR,
+ "Error getting average power consumption history data.");
+ return -1;
+ } else if ((iDRAC_FLAG == IDRAC_12G) && (rc == LICENSE_NOT_SUPPORTED)) {
+ lprintf(LOG_ERR,
+ "FM001 : A required license is missing or expired");
+ return -1;
+ } else if ((rc == 0xc1) || (rc == 0xcb)) {
+ lprintf(LOG_ERR, "Error getting average power consumption history data: "
+ "Command not supported on this system.");
+ return -1;
+ } else if (rc != 0) {
+ lprintf(LOG_ERR,
+ "Error getting average power consumption history data: %s",
+ val2str(rc, completion_code_vals));
+ return -1;
+ }
+ if (verbose > 1) {
+ rdata = (void *)pavgpower;
+ printf("Average power consumption history data"
+ " :%x %x %x %x %x %x %x %x\n\n",
+ rdata[0], rdata[1], rdata[2], rdata[3],
+ rdata[4], rdata[5], rdata[6], rdata[7]);
+ }
+# 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(struct ipmi_intf * intf,
+ IPMI_POWER_CONSUMP_HISTORY * pstPeakpower)
+{
+ uint8_t *rdata;
+ int rc;
+ rc = ipmi_mc_getsysinfo(intf, 0xec, 0, 0, sizeof(*pstPeakpower),
+ pstPeakpower);
+ if (rc < 0) {
+ lprintf(LOG_ERR, "Error getting peak power consumption history data.");
+ return -1;
+ } else if ((iDRAC_FLAG == IDRAC_12G) && (rc == LICENSE_NOT_SUPPORTED)) {
+ lprintf(LOG_ERR,
+ "FM001 : A required license is missing or expired");
+ return -1;
+ } else if ((rc == 0xc1) || (rc == 0xcb)) {
+ lprintf(LOG_ERR, "Error getting peak power consumption history data: "
+ "Command not supported on this system.");
+ return -1;
+ } else if (rc != 0) {
+ lprintf(LOG_ERR, "Error getting peak power consumption history data: %s",
+ val2str(rc, completion_code_vals));
+ return -1;
+ }
+ if (verbose > 1) {
+ rdata = (void *)pstPeakpower;
+ 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 %x\n\n",
+ rdata[0], rdata[1], rdata[2], rdata[3],
+ rdata[4], rdata[5], rdata[6], rdata[7],
+ rdata[8], rdata[9], rdata[10], rdata[11],
+ rdata[12], rdata[13], rdata[14], rdata[15],
+ rdata[16], rdata[17], rdata[18], rdata[19],
+ rdata[20], rdata[21], rdata[22], rdata[23]);
+ }
+# 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(struct ipmi_intf * intf,
+ IPMI_POWER_CONSUMP_HISTORY * pstMinpower)
+{
+ uint8_t *rdata;
+ int rc;
+ rc = ipmi_mc_getsysinfo(intf, 0xed, 0, 0, sizeof(*pstMinpower),
+ pstMinpower);
+ if (rc < 0) {
+ lprintf(LOG_ERR, "Error getting peak power consumption history data .");
+ return -1;
+ } else if ((iDRAC_FLAG == IDRAC_12G) && (rc == LICENSE_NOT_SUPPORTED)) {
+ lprintf(LOG_ERR,
+ "FM001 : A required license is missing or expired");
+ return -1;
+ } else if ((rc == 0xc1) || (rc == 0xcb)) {
+ lprintf(LOG_ERR, "Error getting peak power consumption history data: "
+ "Command not supported on this system.");
+ return -1;
+ } else if (rc != 0) {
+ lprintf(LOG_ERR, "Error getting peak power consumption history data: %s",
+ val2str(rc, completion_code_vals));
+ return -1;
+ }
+ if (verbose > 1) {
+ rdata = (void *)pstMinpower;
+ 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",
+ rdata[0], rdata[1], rdata[2], rdata[3],
+ rdata[4], rdata[5], rdata[6], rdata[7],
+ rdata[8], rdata[9], rdata[10], rdata[11],
+ rdata[12], rdata[13], rdata[14], rdata[15],
+ rdata[16], rdata[17], rdata[18], rdata[19],
+ rdata[20], rdata[21], rdata[22], rdata[23]);
+ }
+# 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(struct ipmi_intf * intf, int unit)
+{
+ char timestr[30];
+ uint32_t lastminutepeakpower;
+ uint32_t lasthourpeakpower;
+ uint32_t lastdaypeakpower;
+ uint32_t lastweekpeakpower;
+ uint64_t tempbtuphrconv;
+ int rc = 0;
+
+ IPMI_AVGPOWER_CONSUMP_HISTORY avgpower;
+ IPMI_POWER_CONSUMP_HISTORY stMinpower;
+ IPMI_POWER_CONSUMP_HISTORY stPeakpower;
+
+ rc = ipmi_get_avgpower_consmpt_history(intf, &avgpower);
+ if (rc == (-1)) {
+ return rc;
+ }
+
+ rc = ipmi_get_peakpower_consmpt_history(intf, &stPeakpower);
+ if (rc == (-1)) {
+ return rc;
+ }
+
+ rc = ipmi_get_minpower_consmpt_history(intf, &stMinpower);
+ if (rc == (-1)) {
+ return rc;
+ }
+ if (rc != 0) {
+ return rc;
+ }
+ printf("Power Consumption History\n\n");
+ /* The fields are alligned manually changing the spaces will alter
+ * the alignment*/
+ printf("Statistic Last Minute Last Hour "
+ "Last Day Last Week\n\n");
+ if (unit == btuphr) {
+ printf("Average Power Consumption ");
+ tempbtuphrconv = watt_to_btuphr_conversion(avgpower.lastminutepower);
+ printf("%4lld BTU/hr ", tempbtuphrconv);
+ tempbtuphrconv = watt_to_btuphr_conversion(avgpower.lasthourpower);
+ printf("%4lld BTU/hr ", tempbtuphrconv);
+ tempbtuphrconv = watt_to_btuphr_conversion(avgpower.lastdaypower);
+ printf("%4lld BTU/hr ", tempbtuphrconv);
+ tempbtuphrconv = watt_to_btuphr_conversion(avgpower.lastweakpower);
+ printf("%4lld BTU/hr\n", tempbtuphrconv);
+
+ printf("Max Power Consumption ");
+ tempbtuphrconv = watt_to_btuphr_conversion(stPeakpower.lastminutepower);
+ printf("%4lld BTU/hr ", tempbtuphrconv);
+ tempbtuphrconv = watt_to_btuphr_conversion(stPeakpower.lasthourpower);
+ printf("%4lld BTU/hr ", tempbtuphrconv);
+ tempbtuphrconv = watt_to_btuphr_conversion(stPeakpower.lastdaypower);
+ printf("%4lld BTU/hr ", tempbtuphrconv);
+ tempbtuphrconv = watt_to_btuphr_conversion(stPeakpower.lastweakpower);
+ printf("%4lld BTU/hr\n", tempbtuphrconv);
+
+ printf("Min Power Consumption ");
+ tempbtuphrconv = watt_to_btuphr_conversion(stMinpower.lastminutepower);
+ printf("%4lld BTU/hr ", tempbtuphrconv);
+ tempbtuphrconv = watt_to_btuphr_conversion(stMinpower.lasthourpower);
+ printf("%4lld BTU/hr ", tempbtuphrconv);
+ tempbtuphrconv = watt_to_btuphr_conversion(stMinpower.lastdaypower);
+ printf("%4lld BTU/hr ", tempbtuphrconv);
+ tempbtuphrconv = watt_to_btuphr_conversion(stMinpower.lastweakpower);
+ printf("%4lld BTU/hr\n\n", tempbtuphrconv);
+ } else {
+ printf("Average Power Consumption ");
+ tempbtuphrconv = (avgpower.lastminutepower);
+ printf("%4lld W ", tempbtuphrconv);
+ tempbtuphrconv = (avgpower.lasthourpower);
+ printf("%4lld W ", tempbtuphrconv);
+ tempbtuphrconv = (avgpower.lastdaypower);
+ printf("%4lld W ", tempbtuphrconv);
+ tempbtuphrconv=(avgpower.lastweakpower);
+ printf("%4lld W \n", tempbtuphrconv);
+
+ printf("Max Power Consumption ");
+ tempbtuphrconv = (stPeakpower.lastminutepower);
+ printf("%4lld W ", tempbtuphrconv);
+ tempbtuphrconv = (stPeakpower.lasthourpower);
+ printf("%4lld W ", tempbtuphrconv);
+ tempbtuphrconv = (stPeakpower.lastdaypower);
+ printf("%4lld W ", tempbtuphrconv);
+ tempbtuphrconv = (stPeakpower.lastweakpower);
+ printf("%4lld W \n", tempbtuphrconv);
+
+ printf("Min Power Consumption ");
+ tempbtuphrconv = (stMinpower.lastminutepower);
+ printf("%4lld W ", tempbtuphrconv);
+ tempbtuphrconv = (stMinpower.lasthourpower);
+ printf("%4lld W ", tempbtuphrconv);
+ tempbtuphrconv = (stMinpower.lastdaypower);
+ printf("%4lld W ", tempbtuphrconv);
+ tempbtuphrconv = (stMinpower.lastweakpower);
+ printf("%4lld W \n\n", tempbtuphrconv);
+ }
+
+ lastminutepeakpower = stPeakpower.lastminutepowertime;
+ lasthourpeakpower = stPeakpower.lasthourpowertime;
+ lastdaypeakpower = stPeakpower.lastdaypowertime;
+ lastweekpeakpower = stPeakpower.lastweekpowertime;
+
+ printf("Max Power Time\n");
+ 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");
+ 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(struct ipmi_intf * intf, IPMI_POWER_CAP * ipmipowercap)
+{
+ uint64_t tempbtuphrconv;
+ uint8_t *rdata;
+ int rc;
+ rc = ipmi_mc_getsysinfo(intf, IPMI_DELL_POWER_CAP, 0, 0,
+ sizeof(*ipmipowercap), ipmipowercap);
+ if (rc < 0) {
+ lprintf(LOG_ERR, "Error getting power cap.");
+ return -1;
+ } else if ((iDRAC_FLAG == IDRAC_12G) && (rc == LICENSE_NOT_SUPPORTED)) {
+ lprintf(LOG_ERR,
+ "FM001 : A required license is missing or expired");
+ return -1;
+ } else if ((rc == 0xc1) || (rc == 0xcb)) {
+ lprintf(LOG_ERR, "Error getting power cap: "
+ "Command not supported on this system.");
+ return -1;
+ } else if (rc != 0) {
+ lprintf(LOG_ERR, "Error getting power cap: %s",
+ val2str(rc, completion_code_vals));
+ return -1;
+ }
+ if (verbose > 1) {
+ rdata = (void*)ipmipowercap;
+ printf("power cap Data :%x %x %x %x %x %x %x %x %x %x ",
+ rdata[1], rdata[2], rdata[3],
+ rdata[4], rdata[5], rdata[6], rdata[7],
+ rdata[8], rdata[9], rdata[10],rdata[11]);
+ }
+# 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(struct ipmi_intf * 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: %lld BTU/hr\n", tempbtuphrconv);
+ tempbtuphrconv = watt_to_btuphr_conversion(ipmipowercap.MinimumPowerConsmp);
+ printf("Minimum power: %lld BTU/hr\n", tempbtuphrconv);
+ tempbtuphrconv = watt_to_btuphr_conversion(ipmipowercap.PowerCap);
+ printf("Power cap : %lld BTU/hr\n", tempbtuphrconv);
+ } else {
+ printf("Maximum power: %d Watt\n", ipmipowercap.MaximumPowerConsmp);
+ printf("Minimum power: %d Watt\n", ipmipowercap.MinimumPowerConsmp);
+ printf("Power cap : %d 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(struct ipmi_intf * intf, int unit, int val)
+{
+ int rc;
+ uint8_t data[13], *rdata;
+ 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;
+ }
+ rc = ipmi_mc_getsysinfo(intf, IPMI_DELL_POWER_CAP, 0, 0,
+ sizeof(ipmipowercap), &ipmipowercap);
+ if (rc < 0) {
+ lprintf(LOG_ERR, "Error getting power cap.");
+ return -1;
+ } else if ((iDRAC_FLAG == IDRAC_12G) && (rc == LICENSE_NOT_SUPPORTED)) {
+ lprintf(LOG_ERR,
+ "FM001 : A required license is missing or expired");
+ return -1;
+ } else if (rc == 0xc1) {
+ lprintf(LOG_ERR, "Error getting power cap, command not supported on "
+ "this system.");
+ return -1;
+ } else if (rc != 0) {
+ lprintf(LOG_ERR, "Error getting power cap: %s",
+ val2str(rc, completion_code_vals));
+ return -1;
+ }
+ if (verbose > 1) {
+ rdata = (void *)&ipmipowercap;
+ printf("power cap Data :%x %x %x %x %x %x %x %x %x %x %x ",
+ rdata[1], rdata[2], rdata[3],
+ rdata[4], rdata[5], rdata[6], rdata[7],
+ rdata[8], rdata[9], rdata[10],rdata[11]);
+ }
+# if WORDS_BIGENDIAN
+ ipmipowercap.PowerCap = BSWAP_16(ipmipowercap.PowerCap);
+ ipmipowercap.MaximumPowerConsmp = BSWAP_16(ipmipowercap.MaximumPowerConsmp);
+ ipmipowercap.MinimumPowerConsmp = BSWAP_16(ipmipowercap.MinimumPowerConsmp);
+ ipmipowercap.AvailablePower = BSWAP_16(ipmipowercap.AvailablePower);
+ ipmipowercap.totalnumpowersupp = BSWAP_16(ipmipowercap.totalnumpowersupp);
+# endif
+ memset(data, 0, 13);
+ 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] = (ipmipowercap.totalnumpowersupp);
+ data[9] = ((ipmipowercap.AvailablePower & 0xFF));
+ data[10] = ((ipmipowercap.AvailablePower & 0xFF00) >> 8);
+ data[11] = (ipmipowercap.SystemThrottling);
+ data[12] = 0x00;
+
+ 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;
+ }
+ rc = ipmi_mc_setsysinfo(intf, 13, data);
+ if (rc < 0) {
+ lprintf(LOG_ERR, "Error setting power cap");
+ return -1;
+ } else if ((iDRAC_FLAG == IDRAC_12G) && (rc == LICENSE_NOT_SUPPORTED)) {
+ lprintf(LOG_ERR,
+ "FM001 : A required license is missing or expired");
+ return -1;
+ } else if (rc > 0) {
+ lprintf(LOG_ERR, "Error setting power cap: %s",
+ val2str(rc, completion_code_vals));
+ return -1;
+ }
+ if (verbose > 1) {
+ printf("CC for setpowercap :%d ", rc);
+ }
+ return 0;
+}
+/*
+ * 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(struct ipmi_intf * 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(struct ipmi_intf * intf) {
+ struct ipmi_rs * rsp;
+ 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 = 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;
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error in getting SD Card Extended Information");
+ return -1;
+ } else if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, "Error in getting SD Card Extended Information (%s)",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+
+ sdcardinfoblock = (IPMI_DELL_SDCARD_INFO *) (void *) rsp->data;
+
+ if ((iDRAC_FLAG == IDRAC_12G)
+ && (sdcardinfoblock->vflashcompcode == VFL_NOT_LICENSED)) {
+ lprintf(LOG_ERR,
+ "FM001 : A required license is missing or expired");
+ return -1;
+ } else if (sdcardinfoblock->vflashcompcode != 0x00) {
+ lprintf(LOG_ERR, "Error in getting SD Card Extended Information (%s)",
+ 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 of");
+ lprintf(LOG_ERR,
+ "size 256MB or greater");
+ return (-1);
+ }
+
+ 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(struct ipmi_intf * intf, int current_arg, char ** argv)
+{
+ int rc;
+ if (strncmp(intf->name,"wmi\0",4) && strncmp(intf->name, "open\0",5)) {
+ lprintf(LOG_ERR,
+ "vFlash support is enabled only for wmi and open interface.");
+ lprintf(LOG_ERR, "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;
+ }
+ } else {
+ /* TBD other vFlash subcommands */
+ ipmi_vFlash_usage();
+ return -1;
+ }
+}
+/*
+ * 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_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 int
+IsSetLEDSupported(void)
+{
+ return SetLEDSupported;
+}
+
+static void
+CheckSetLEDSupport(struct ipmi_intf * intf)
+{
+ struct ipmi_rs * rsp = NULL;
+ struct ipmi_rq req = {0};
+ uint8_t data[10];
+
+ SetLEDSupported = 0;
+ req.msg.netfn = DELL_OEM_NETFN;
+ req.msg.lun = 0;
+ req.msg.cmd = 0xD5; /* Storage */
+ req.msg.data_len = 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;
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL || rsp->ccode != 0) {
+ return;
+ }
+ SetLEDSupported = 1;
+}
+/*
+ * 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(struct ipmi_intf * intf, int b, int d, int f, int *bay,
+ int *slot)
+{
+ struct ipmi_rs * rsp = NULL;
+ struct ipmi_rq req = {0};
+ uint8_t data[8];
+ /* Get mapping of BDF to bay:slot */
+ req.msg.netfn = 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 */
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error issuing getdrivemap command.");
+ return -1;
+ } else if (rsp->ccode != 0) {
+ lprintf(LOG_ERR, "Error issuing getdrivemap command: %s",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+ *bay = rsp->data[7];
+ *slot = rsp->data[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(struct ipmi_intf * intf, int bayId, int slotId, int state)
+{
+ struct ipmi_rs * rsp = NULL;
+ struct ipmi_rq req = {0};
+ uint8_t data[20];
+ /* Issue Drive Status Update to bay:slot */
+ req.msg.netfn = 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; */
+
+ rsp = intf->sendrecv(intf, &req);
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error issuing setled command.");
+ return -1;
+ } else if (rsp->ccode != 0) {
+ lprintf(LOG_ERR, "Error issuing setled command: %s",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+ return 0;
+}
+/*
+ * 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;
+ 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(struct ipmi_intf * intf, int argc, char ** argv)
+{
+ int b,d,f, mask;
+ int bayId, slotId;
+ bayId = 0xFF;
+ slotId = 0xFF;
+ current_arg++;
+ if (argc < current_arg) {
+ usage();
+ return -1;
+ }
+ /* ipmitool delloem setled info*/
+ if (argc == 1 || strcmp(argv[current_arg], "help") == 0) {
+ ipmi_setled_usage();
+ return 0;
+ }
+ CheckSetLEDSupport(intf);
+ if (!IsSetLEDSupported()) {
+ lprintf(LOG_ERR, "'setled' is not supported on this system.");
+ return -1;
+ } 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);
+}