diff options
Diffstat (limited to 'lib/ipmi_delloem.c')
| -rw-r--r-- | lib/ipmi_delloem.c | 4225 |
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); +} |