/* * Copyright (C) 2008 Intel Corporation. * All rights reserved * * 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. * */ /* Theory of operation * * DCMI is the Data Center Management Interface which is a subset of IPMI v2.0. * DCMI incorporates the ability to locate a system with DCMI functionality, * its available temperature sensors, and power limiting control. * * All of the available DCMI commands are contained in a struct with a numeric * value and a string. When the user specifies a command the string is * compared to one of several structs and is then given a numeric value based * on the matched string. A case statement is used to select the desired * action from the user. If an invalid string is entered, or a string that is * not a command option is entered, the available commands are printed to the * screen. This allows the strings to be changed quickly with the DCMI spec. * * Each called function usually executes whichever command was requested to * keep the main() from being overly complicated. * * This code conforms to the 1.0 DCMI Specification * released by Hari Ramachandran of the Intel Corporation */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "../src/plugins/lanplus/lanplus.h" #define IPMI_LAN_PORT 0x26f extern int verbose; static int ipmi_print_sensor_info(struct ipmi_intf *intf, uint16_t rec_id); /******************************************************************************* * The structs below are the DCMI command option strings. They are printed * * when the user does not issue enough options or the wrong ones. The reason * * that the DMCI command strings are in a struct is so that when the * * specification changes, the strings can be changed quickly with out having * * to change a lot of the code in the main(). * ******************************************************************************/ /* Main set of DCMI commands */ const struct dcmi_cmd dcmi_cmd_vals[] = { { 0x00, "discover", " Used to discover supported DCMI capabilities" }, { 0x01, "power", " Platform power limit command options" }, { 0x02, "sensors", " Prints the available DCMI sensors" }, { 0x03, "asset_tag", " Prints the platform's asset tag" }, { 0x04, "set_asset_tag", " Sets the platform's asset tag" }, { 0x05, "get_mc_id_string", " Get management controller ID string" }, { 0x06, "set_mc_id_string", " Set management controller ID string" }, { 0x07, "thermalpolicy", " Thermal policy get/set" }, { 0x08, "get_temp_reading", " Get Temperature Readings" }, { 0x09, "get_conf_param", " Get DCMI Config Parameters" }, { 0x0A, "set_conf_param", " Set DCMI Config Parameters" }, { 0x0B, "oob_discover", " Ping/Pong Message for DCMI Discovery" }, { 0xFF, NULL, NULL } }; /* get capabilites */ const struct dcmi_cmd dcmi_capable_vals[] = { { 0x01, "platform", " Lists the system capabilities" }, { 0x02, "mandatory_attributes", "Lists SEL, identification and" "temperature attributes" }, { 0x03, "optional_attributes", " Lists power capabilities" }, { 0x04, "managebility access", " Lists OOB channel information" }, { 0xFF, NULL, NULL } }; /* platform capabilities * Since they are actually in two bytes, we need three structs to make this * human readable... */ const struct dcmi_cmd dcmi_mandatory_platform_capabilities[] = { { 0x01, "Identification support available", "" }, { 0x02, "SEL logging available", "" }, { 0x03, "Chassis power available", "" }, { 0x04, "Temperature monitor available", "" }, { 0xFF, NULL, NULL } }; /* optional capabilities */ const struct dcmi_cmd dcmi_optional_platform_capabilities[] = { { 0x01, "Power management available", "" }, { 0xFF, NULL, NULL } }; /* access capabilties */ const struct dcmi_cmd dcmi_management_access_capabilities[] = { { 0x01, "In-band KCS channel available", "" }, { 0x02, "Out-of-band serial TMODE available", "" }, { 0x03, "Out-of-band secondary LAN channel available", "" }, { 0x04, "Out-of-band primary LAN channel available", "" }, { 0x05, "SOL enabled", "" }, { 0x06, "VLAN capable", "" }, { 0xFF, NULL, NULL } }; /* identification capabilities */ const struct dcmi_cmd dcmi_id_capabilities_vals[] = { { 0x01, "GUID", "" }, { 0x02, "DHCP hostname", "" }, { 0x03, "Asset tag", "" }, { 0xFF, NULL, NULL } }; /* Configuration parameters*/ const struct dcmi_cmd dcmi_conf_param_vals[] = { { 0x01, "activate_dhcp", "\tActivate DHCP"}, { 0x02, "dhcp_config", "\tDHCP Configuration" }, { 0x03, "init", "\t\tInitial timeout interval" }, { 0x04, "timeout", "\t\tServer contact timeout interval" }, { 0x05, "retry", "\t\tServer contact retry interval" }, { 0xFF, NULL, NULL } }; /* temperature monitoring capabilities */ const struct dcmi_cmd dcmi_temp_monitoring_vals[] = { { 0x01, "inlet", " Inlet air temperature sensors" }, { 0x02, "cpu", " CPU temperature sensors" }, { 0x03, "baseboard", "Baseboard temperature sensors" }, { 0xff, NULL, NULL } }; /* These are not comands. These are the DCMI temp sensors and their numbers * If new sensors are added, they need to be added to this list with their * sensor number */ const struct dcmi_cmd dcmi_discvry_snsr_vals[] = { { 0x40, "Inlet", " Inlet air temperature sensors" }, { 0x41, "CPU", " CPU temperature sensors" }, { 0x42, "Baseboard", "Baseboard temperature sensors" }, { 0xff, NULL, NULL } }; /* Temperature Readings */ const struct dcmi_cmd dcmi_temp_read_vals[] = { { 0x40, "Inlet", "Inlet air temperature(40h) " }, { 0x41, "CPU", "CPU temperature sensors(41h) " }, { 0x42, "Baseboard", "Baseboard temperature sensors(42h) " }, { 0xff, NULL, NULL } }; /* power management/control commands */ const struct dcmi_cmd dcmi_pwrmgmt_vals[] = { { 0x00, "reading", " Get power related readings from the system" }, { 0x01, "get_limit", " Get the configured power limits" }, { 0x02, "set_limit", " Set a power limit option" }, { 0x03, "activate", " Activate the set power limit" }, { 0x04, "deactivate", "Deactivate the set power limit" }, { 0xFF, NULL, NULL } }; /* set power limit commands */ const struct dcmi_cmd dcmi_pwrmgmt_set_usage_vals[] = { { 0x00, "action", " " }, { 0x01, "limit", " " }, { 0x02, "correction", "" }, { 0x03, "sample", " " }, { 0xFF, NULL, NULL } }; /* power management/get action commands */ const struct dcmi_cmd dcmi_pwrmgmt_get_action_vals[] = { { 0x00, "No Action", ""}, { 0x01, "Hard Power Off & Log Event to SEL", ""}, { 0x02, "OEM reserved (02h)", ""}, { 0x03, "OEM reserved (03h)", ""}, { 0x04, "OEM reserved (04h)", ""}, { 0x05, "OEM reserved (05h)", ""}, { 0x06, "OEM reserved (06h)", ""}, { 0x07, "OEM reserved (07h)", ""}, { 0x08, "OEM reserved (08h)", ""}, { 0x09, "OEM reserved (09h)", ""}, { 0x0a, "OEM reserved (0ah)", ""}, { 0x0b, "OEM reserved (0bh)", ""}, { 0x0c, "OEM reserved (0ch)", ""}, { 0x0d, "OEM reserved (0dh)", ""}, { 0x0e, "OEM reserved (0eh)", ""}, { 0x0f, "OEM reserved (0fh)", ""}, { 0x10, "OEM reserved (10h)", ""}, { 0x11, "Log Event to SEL", ""}, { 0xFF, NULL, NULL } }; /* power management/set action commands */ const struct dcmi_cmd dcmi_pwrmgmt_action_vals[] = { { 0x00, "no_action", "No Action"}, { 0x01, "power_off", "Hard Power Off & Log Event to SEL"}, { 0x11, "sel_logging", "Log Event to SEL"}, { 0x02, "oem_02", "OEM reserved (02h)"}, { 0x03, "oem_03", "OEM reserved (03h)"}, { 0x04, "oem_04", "OEM reserved (04h)"}, { 0x05, "oem_05", "OEM reserved (05h)"}, { 0x06, "oem_06", "OEM reserved (06h)"}, { 0x07, "oem_07", "OEM reserved (07h)"}, { 0x08, "oem_08", "OEM reserved (08h)"}, { 0x09, "oem_09", "OEM reserved (09h)"}, { 0x0a, "oem_0a", "OEM reserved (0ah)"}, { 0x0b, "oem_0b", "OEM reserved (0bh)"}, { 0x0c, "oem_0c", "OEM reserved (0ch)"}, { 0x0d, "oem_0d", "OEM reserved (0dh)"}, { 0x0e, "oem_0e", "OEM reserved (0eh)"}, { 0x0f, "oem_0f", "OEM reserved (0fh)"}, { 0x10, "oem_10", "OEM reserved (10h)"}, { 0xFF, NULL, NULL } }; /* thermal policy action commands */ const struct dcmi_cmd dcmi_thermalpolicy_vals[] = { { 0x00, "get", "Get thermal policy" }, { 0x01, "set", "Set thermal policy" }, { 0xFF, NULL, NULL } }; /* thermal policy action commands */ const struct dcmi_cmd dcmi_confparameters_vals[] = { { 0x00, "get", "Get configuration parameters" }, { 0x01, "set", "Set configuration parameters" }, { 0xFF, NULL, NULL } }; /* entityIDs used in thermap policy */ const struct dcmi_cmd dcmi_thermalpolicy_set_parameters_vals[] = { { 0x00, "volatile", " Current Power Cycle" }, { 0x01, "nonvolatile", "Set across power cycles" }, { 0x01, "poweroff", " Hard Power Off system" }, { 0x00, "nopoweroff", " No 'Hard Power Off' action" }, { 0x01, "sel", " Log event to SEL" }, { 0x00, "nosel", " No 'Log event to SEL' action" }, { 0x00, "disabled", " Disabled" }, { 0x00, NULL, NULL } }; /* DCMI command specific completion code results per 1.0 spec * 80h - parameter not supported. * 81h - attempt to set the ‘set in progress’ value (in parameter #0) when not * in the ‘set complete’ state. (This completion code provides a way to * recognize that another party has already ‘claimed’ the parameters) * 82h - attempt to write read-only parameter * 82h - set not supported on selected channel (e.g. channel is session-less.) * 83h - access mode not supported * 84h – Power Limit out of range * 85h – Correction Time out of range * 89h – Statistics Reporting Period out of range */ const struct valstr dcmi_ccode_vals[] = { { 0x80, "Parameter not supported" }, { 0x81, "Something else has already claimed these parameters" }, { 0x82, "Not supported or failed to write a read-only parameter" }, { 0x83, "Access mode is not supported" }, { 0x84, "Power/Thermal limit out of range" }, { 0x85, "Correction/Exception time out of range" }, { 0x89, "Sample/Statistics Reporting period out of range" }, { 0x8A, "Power limit already active" }, { 0xFF, NULL } }; /* End strings */ /* This was taken from print_valstr() from helper.c. It serves the same * purpose but with out the extra formatting. This function simply prints * the dcmi_cmd struct provided. verthorz specifies to print vertically or * horizontally. If the string is printed horizontally then a | will be * printed between each instance of vs[i].str until it is NULL * * @vs: value string list to print * @title: name of this value string list * @loglevel: what log level to print, -1 for stdout * @verthorz: printed vertically or horizontally, 0 or 1 */ void print_strs(const struct dcmi_cmd * vs, const char * title, int loglevel, int verthorz) { int i; if (vs == NULL) return; if (title != NULL) { if (loglevel < 0) printf("\n%s\n", title); else lprintf(loglevel, "\n%s", title); } for (i = 0; vs[i].str != NULL; i++) { if (loglevel < 0) { if (vs[i].val < 256) if (verthorz == 0) printf(" %s %s\n", vs[i].str, vs[i].desc); else printf("%s", vs[i].str); else if (verthorz == 0) printf(" %s %s\n", vs[i].str, vs[i].desc); else printf("%s", vs[i].str); } else { if (vs[i].val < 256) lprintf(loglevel, " %s %s", vs[i].str, vs[i].desc); else lprintf(loglevel, " %s %s", vs[i].str, vs[i].desc); } /* Check to see if this is NOT the last element in vs.str if true * print the | else don't print anything. */ if ((verthorz == 1) && (vs[i+1].str != NULL)) printf(" | "); } if (verthorz == 0) { if (loglevel < 0) { printf("\n"); } else { lprintf(loglevel, ""); } } } /* This was taken from str2val() from helper.c. It serves the same * purpose but with the addition of a desc field from the structure. * This function converts the str from the dcmi_cmd struct provided to the * value associated to the compared string in the struct. * * @str: string to compare against * @vs: dcmi_cmd structure */ uint16_t str2val2(const char *str, const struct dcmi_cmd *vs) { int i; if (vs == NULL || str == NULL) { return 0; } for (i = 0; vs[i].str != NULL; i++) { if (strncasecmp(vs[i].str, str, __maxlen(str, vs[i].str)) == 0) { return vs[i].val; } } return vs[i].val; } /* This was taken from val2str() from helper.c. It serves the same * purpose but with the addition of a desc field from the structure. * This function converts the val and returns a string from the dcmi_cmd * struct provided in the struct. * * @val: value to compare against * @vs: dcmi_cmd structure */ const char * val2str2(uint16_t val, const struct dcmi_cmd *vs) { static char un_str[32]; int i; if (vs == NULL) return NULL; for (i = 0; vs[i].str != NULL; i++) { if (vs[i].val == val) return vs[i].str; } memset(un_str, 0, 32); snprintf(un_str, 32, "Unknown (0x%x)", val); return un_str; } /* check the DCMI response from the BMC * @rsp: Response data structure */ static int chk_rsp(struct ipmi_rs * rsp) { /* if the response from the intf is NULL then the BMC is experiencing * some issue and cannot complete the command */ if (rsp == NULL) { lprintf(LOG_ERR, "\n Unable to get DCMI information"); return 1; } /* if the completion code is greater than zero there was an error. We'll * use val2str from helper.c to print the error from either the DCMI * completion code struct or the generic IPMI completion_code_vals struct */ if ((rsp->ccode >= 0x80) && (rsp->ccode <= 0x8F)) { lprintf(LOG_ERR, "\n DCMI request failed because: %s (%x)", val2str(rsp->ccode, dcmi_ccode_vals), rsp->ccode); return 1; } else if (rsp->ccode > 0) { lprintf(LOG_ERR, "\n DCMI request failed because: %s (%x)", val2str(rsp->ccode, completion_code_vals), rsp->ccode); return 1; } /* check to make sure this is a DCMI firmware */ if(rsp->data[0] != IPMI_DCMI) { printf("\n A valid DCMI command was not returned! (%x)", rsp->data[0]); return 1; } return 0; } /* Get capabilities ipmi response * * This function returns the available capabilities of the platform. * The reason it returns in the rsp struct is so that it can be used for other * purposes. * * returns ipmi response structure * * @intf: ipmi interface handler * @selector: Parameter selector */ struct ipmi_rs * ipmi_dcmi_getcapabilities(struct ipmi_intf * intf, uint8_t selector) { struct ipmi_rq req; /* request data to send to the BMC */ uint8_t msg_data[2]; /* 'raw' data to be sent to the BMC */ msg_data[0] = IPMI_DCMI; /* Group Extension Identification */ msg_data[1] = selector; memset(&req, 0, sizeof(req)); req.msg.netfn = IPMI_NETFN_DCGRP; /* 0x2C per 1.0 spec */ req.msg.cmd = IPMI_DCMI_COMPAT; /* 0x01 per 1.0 spec */ req.msg.data = msg_data; /* 0xDC 0x01 or the msg_data above */ req.msg.data_len = 2; /* How many times does req.msg.data need to read */ return intf->sendrecv(intf, &req); } /* end capabilities struct */ /* Displays capabilities from structure * returns void * * @cmd: dcmi_cmd structure * @data_val: holds value of what to display */ void display_capabilities_attributes(const struct dcmi_cmd *cmd, uint8_t data_val) { uint8_t i; for (i = 0x01; cmd[i-1].val != 0xFF; i++) { if (data_val & (1<<(i-1))) { printf(" %s\n", val2str2(i, cmd)); } } } static int ipmi_dcmi_prnt_oobDiscover(struct ipmi_intf * intf) { # ifndef IPMI_INTF_LANPLUS lprintf(LOG_ERR, "DCMI Discovery is available only when LANplus(IPMI v2.0) is enabled."); return (-1); # else int rc; struct ipmi_session *s; if (intf->opened == 0 && intf->open != NULL) { if (intf->open(intf) < 0) return (-1); } if (intf == NULL || intf->session == NULL) return -1; s = intf->session; if (s->port == 0) s->port = IPMI_LAN_PORT; if (s->privlvl == 0) s->privlvl = IPMI_SESSION_PRIV_ADMIN; if (s->timeout == 0) s->timeout = IPMI_LAN_TIMEOUT; if (s->retry == 0) s->retry = IPMI_LAN_RETRY; if (s->hostname == NULL || strlen((const char *)s->hostname) == 0) { lprintf(LOG_ERR, "No hostname specified!"); return -1; } intf->abort = 1; intf->session->sol_data.sequence_number = 1; if (ipmi_intf_socket_connect (intf) == -1) { lprintf(LOG_ERR, "Could not open socket!"); return -1; } if (intf->fd < 0) { lperror(LOG_ERR, "Connect to %s failed", s->hostname); intf->close(intf); return -1; } intf->opened = 1; /* Lets ping/pong */ return ipmiv2_lan_ping(intf); # endif } /* This is the get DCMI Capabilities function to see what the BMC supports. * * returns 0 with out error -1 with any errors * * @intf: ipmi interface handler * @selector: selection parameter */ static int ipmi_dcmi_prnt_getcapabilities(struct ipmi_intf * intf, uint8_t selector) { uint8_t i; uint8_t bit_shifter = 0; struct capabilities cape; struct ipmi_rs * rsp; rsp = ipmi_dcmi_getcapabilities(intf, selector); if(chk_rsp(rsp)) return -1; /* if there were no errors, the command worked! */ memcpy(&cape, rsp->data, sizeof (cape)); /* check to make sure that this is a 1.0/1.1/1.5 command */ if ((cape.conformance != IPMI_DCMI_CONFORM) && (cape.conformance != IPMI_DCMI_1_1_CONFORM) && (cape.conformance != IPMI_DCMI_1_5_CONFORM)) { lprintf(LOG_ERR, "ERROR! This command is not available on this platform"); return -1; } /* check to make sure that this is a rev .01 or .02 */ if (cape.revision != 0x01 && cape.revision != 0x02) { lprintf(LOG_ERR, "ERROR! This command is not compatible with this version"); return -1; } /* 0x01 - platform capabilities * 0x02 - Manageability Access Capabilities * 0x03 - SEL Capability * 0x04 - Identification Capability * 0x05 - LAN Out-Of-Band Capability * 0x06 - Serial Out-Of-Band TMODE Capability */ switch (selector) { case 0x01: printf(" Supported DCMI capabilities:\n"); /* loop through each of the entries in the first byte from the * struct */ printf("\n Mandatory platform capabilties\n"); display_capabilities_attributes( dcmi_mandatory_platform_capabilities, cape.data_byte1); /* loop through each of the entries in the second byte from the * struct */ printf("\n Optional platform capabilties\n"); display_capabilities_attributes( dcmi_optional_platform_capabilities, cape.data_byte2); /* loop through each of the entries in the third byte from the * struct */ printf("\n Managebility access capabilties\n"); display_capabilities_attributes( dcmi_management_access_capabilities, cape.data_byte3); break; case 0x02: printf("\n Mandatory platform attributes:\n"); /* byte 1 & 2 data */ printf("\n SEL Attributes: "); printf("\n SEL automatic rollover is "); /* mask the 2nd byte of the data response with 10000000b or 0x80 * because of the endian-ness the 15th bit is in the second byte */ if ((cape.data_byte2 & 0x80)) printf("enabled"); else printf("not present"); /* since the number of SEL entries is split across the two data * bytes we will need to bit shift and append them together again */ /* cast cape.data_byte1 as 16 bits */ uint16_t sel_entries = (uint16_t)cape.data_byte1; /* or sel_entries with byte 2 and shift it 8 places */ sel_entries |= (uint16_t)cape.data_byte2 << 8; printf("\n %d SEL entries\n", sel_entries & 0xFFF); /* byte 3 data */ printf("\n Identification Attributes: \n"); display_capabilities_attributes( dcmi_id_capabilities_vals, cape.data_byte3); /* byte 4 data */ printf("\n Temperature Monitoring Attributes: \n"); display_capabilities_attributes(dcmi_temp_monitoring_vals, cape.data_byte4); break; case 0x03: printf("\n Optional Platform Attributes: \n"); /* Power Management */ printf("\n Power Management:\n"); if (cape.data_byte1 == 0x40) { printf(" Slave address of device: 20h (BMC)\n" ); } else { printf(" Slave address of device: %xh (8bits)" "(Satellite/External controller)\n", cape.data_byte1); } /* Controller channel number (4-7) bits */ if ((cape.data_byte2>>4) == 0x00) { printf(" Channel number is 0h (Primary BMC)\n"); } else { printf(" Channel number is %xh \n", (cape.data_byte2>>4)); } /* Device revision (0-3) */ printf(" Device revision is %d \n", cape.data_byte2 &0xf); break; case 0x04: /* LAN */ printf("\n Manageability Access Attributes: \n"); if (cape.data_byte1 == 0xFF) { printf(" Primary LAN channel is not available for OOB\n"); } else { printf(" Primary LAN channel number: %d is available\n", cape.data_byte1); } if (cape.data_byte2 == 0xFF) { printf(" Secondary LAN channel is not available for OOB\n"); } else { printf(" Secondary LAN channel number: %d is available\n", cape.data_byte2); } /* serial */ if (cape.data_byte3 == 0xFF) { printf(" No serial channel is available\n"); } else { printf(" Serial channel number: %d is available\n", cape.data_byte3); } break; default: return -1; } return 0; /* return intf->sendrecv(intf, &req); */ } /* This is the get asset tag command. This checks the length of the asset tag * with the first read, then reads n number of bytes thereafter to get the * complete asset tag. * * @intf: ipmi interface handler * @offset: where to start reading the asset tag * @length: how much to read * * returns ipmi_rs structure */ struct ipmi_rs * ipmi_dcmi_getassettag(struct ipmi_intf * intf, uint8_t offset, uint8_t length) { struct ipmi_rq req; /* request data to send to the BMC */ uint8_t msg_data[3]; /* 'raw' data to be sent to the BMC */ msg_data[0] = IPMI_DCMI; /* Group Extension Identification */ msg_data[1] = offset; /* offset 0 */ msg_data[2] = length; /* read one byte */ memset(&req, 0, sizeof(req)); req.msg.netfn = IPMI_NETFN_DCGRP; /* 0x2C per 1.1 spec */ req.msg.cmd = IPMI_DCMI_GETASSET; /* 0x01 per 1.1 spec */ req.msg.data = msg_data; /* msg_data above */ req.msg.data_len = 3; /* How many times does req.msg.data need to read */ return intf->sendrecv(intf, &req); } /* This is the get asset tag command. The function first checks to see if the * platform is capable of getting the asset tag by calling the getcapabilities * function and checking the response. Then it checks the length of the asset * tag with the first read, then x number of reads thereafter to get the asset * complete asset tag then print it. * * @intf: ipmi interface handler * * returns 0 if no failure, -1 with a failure */ static int ipmi_dcmi_prnt_getassettag(struct ipmi_intf * intf) { uint8_t data_byte2; struct ipmi_rs * rsp; /* ipmi response */ uint8_t taglength = 0; uint8_t getlength = 0; uint8_t offset = 0; uint8_t i; /* now let's get the asset tag length */ rsp = ipmi_dcmi_getassettag(intf, 0, 0); if (chk_rsp(rsp)) { return -1; } taglength = rsp->data[1]; printf("\n Asset tag: "); while (taglength) { getlength = taglength / DCMI_MAX_BYTE_SIZE ? DCMI_MAX_BYTE_SIZE : taglength%DCMI_MAX_BYTE_SIZE; rsp = ipmi_dcmi_getassettag(intf, offset, getlength); /* macro has no effect here where can generate sig segv * if rsp occurs with null */ if (rsp != NULL) { GOOD_ASSET_TAG_CCODE(rsp->ccode); } if (chk_rsp(rsp)) { return -1; } for (i=0; idata[i+2]); } offset += getlength; taglength -= getlength; } printf("\n"); return 0; } /* This is the set asset tag command. This checks the length of the asset tag * with the first read, then reads n number of bytes thereafter to set the * complete asset tag. * * @intf: ipmi interface handler * @offset: offset to write * @length: number of bytes to write (16 bytes maximum) * @data: data to write * * returns ipmi_rs structure */ struct ipmi_rs * ipmi_dcmi_setassettag(struct ipmi_intf * intf, uint8_t offset, uint8_t length, uint8_t *data) { struct ipmi_rq req; /* request data to send to the BMC */ uint8_t msg_data[3+length]; /* 'raw' data to be sent to the BMC */ msg_data[0] = IPMI_DCMI; /* Group Extension Identification */ msg_data[1] = offset; /* offset 0 */ msg_data[2] = length; /* read one byte */ memset(&req, 0, sizeof(req)); req.msg.netfn = IPMI_NETFN_DCGRP; /* 0x2C per 1.1 spec */ req.msg.cmd = IPMI_DCMI_SETASSET; /* 0x08 per 1.1 spec */ req.msg.data = msg_data; /* msg_data above */ /* How many times does req.msg.data need to read */ req.msg.data_len = length + 3; memcpy(req.msg.data + 3, data, length); return intf->sendrecv(intf, &req); } static int ipmi_dcmi_prnt_setassettag(struct ipmi_intf * intf, uint8_t * data) { uint8_t data_byte2; struct ipmi_rs * rsp; /* ipmi response */ uint8_t tmpData[DCMI_MAX_BYTE_SIZE]; uint8_t taglength = 0; uint8_t getlength = 0; uint8_t offset = 0; uint8_t i; /* now let's get the asset tag length */ taglength = strlen(data); if (taglength > 64){ lprintf(LOG_ERR, "\nValue is too long."); return -1; } printf("\n Set Asset Tag: "); while (taglength) { getlength = taglength / DCMI_MAX_BYTE_SIZE ? DCMI_MAX_BYTE_SIZE : taglength%DCMI_MAX_BYTE_SIZE; memcpy(tmpData, data + offset, getlength); rsp = ipmi_dcmi_setassettag(intf, offset, getlength, tmpData); if (chk_rsp(rsp)) { return -1; } for (i=0; isendrecv(intf, &req); } static int ipmi_dcmi_prnt_getmngctrlids(struct ipmi_intf * intf) { uint8_t data_byte2; struct ipmi_rs * rsp; /* ipmi response */ uint8_t taglength = 0; uint8_t getlength = 0; uint8_t offset = 0; uint8_t i; /* now let's get the asset tag length */ rsp = ipmi_dcmi_getmngctrlids(intf, 0, 1); if (chk_rsp(rsp)) { return -1; } taglength = rsp->data[1]; printf("\n Get Management Controller Identifier String: "); while (taglength) { getlength = taglength / DCMI_MAX_BYTE_SIZE ? DCMI_MAX_BYTE_SIZE : taglength%DCMI_MAX_BYTE_SIZE; rsp = ipmi_dcmi_getmngctrlids(intf, offset, getlength); if (chk_rsp(rsp)) { return -1; } for (i=0; idata[i+2]); } offset += getlength; taglength -= getlength; } printf("\n"); return 0; } /* Management Controller Identifier String is provided in order to accommodate * the requirement for the management controllers to identify themselves. * * @intf: ipmi interface handler * @offset: offset to write * @length: number of bytes to write (16 bytes maximum) * @data: data to write * * returns ipmi_rs structure */ struct ipmi_rs * ipmi_dcmi_setmngctrlids(struct ipmi_intf * intf, uint8_t offset, uint8_t length, uint8_t *data) { struct ipmi_rq req; /* request data to send to the BMC */ uint8_t msg_data[3+length]; /* 'raw' data to be sent to the BMC */ msg_data[0] = IPMI_DCMI; /* Group Extension Identification */ msg_data[1] = offset; /* offset 0 */ msg_data[2] = length; /* read one byte */ memset(&req, 0, sizeof(req)); req.msg.netfn = IPMI_NETFN_DCGRP; /* 0x2C per 1.1 spec */ req.msg.cmd = IPMI_DCMI_SETMNGCTRLIDS; /* 0x0A per 1.1 spec */ req.msg.data = msg_data; /* msg_data above */ /* How many times does req.msg.data need to read */ req.msg.data_len = 3 + length; memcpy(req.msg.data + 3, data, length); return intf->sendrecv(intf, &req); } /* Set Asset Tag command provides ability for the management console to set the * asset tag as appropriate. Management controller is not responsible for the * data format used for the Asset Tag once modified by IPDC. * * @intf: ipmi interface handler * * returns 0 if no failure, -1 with a failure */ static int ipmi_dcmi_prnt_setmngctrlids(struct ipmi_intf * intf, uint8_t * data) { uint8_t data_byte2; struct ipmi_rs * rsp; /* ipmi response */ uint8_t tmpData[DCMI_MAX_BYTE_SIZE]; uint8_t taglength = 0; uint8_t getlength = 0; uint8_t offset = 0; uint8_t i; data += '\0'; taglength = strlen(data) +1; if (taglength > 64) { lprintf(LOG_ERR, "\nValue is too long."); return -1; } printf("\n Set Management Controller Identifier String Command: "); while (taglength) { getlength = taglength / DCMI_MAX_BYTE_SIZE ? DCMI_MAX_BYTE_SIZE : taglength%DCMI_MAX_BYTE_SIZE; memcpy(tmpData, data + offset, getlength); rsp = ipmi_dcmi_setmngctrlids(intf, offset, getlength, tmpData); /* because after call "Set mc id string" RMCP+ will go down * we have no "rsp" */ if (strncmp(intf->name, "lanplus", 7)) { if (chk_rsp(rsp)) { return -1; } } for (i=0; isendrecv(intf, &req); } /* DCMI sensor discovery * Uses the dcmi_discvry_snsr_vals struct to print its string and * uses the numeric values to request the sensor sdr record id. * * @intf: ipmi interface handler * @isnsr: entity ID * @ient: sensor entity id */ static int ipmi_dcmi_prnt_discvry_snsr(struct ipmi_intf * intf, uint8_t isnsr) { int i = 0; struct ipmi_rs * rsp; /* ipmi response */ uint8_t records = 0; int8_t instances = 0; uint8_t offset = 0; uint16_t record_id = 0; uint8_t id_buff[16]; /* enough for 8 record IDs */ rsp = ipmi_dcmi_discvry_snsr(intf, isnsr, 0); if (chk_rsp(rsp)) { return -1; } instances = rsp->data[1]; printf("\n%s: %d temperature sensor%s found:\n", val2str2(isnsr, dcmi_discvry_snsr_vals), instances, (instances > 1) ? "s" : ""); while(instances > 0) { ipmi_dcmi_discvry_snsr(intf, isnsr, offset); if (chk_rsp(rsp)) { return -1; } records = rsp->data[2]; /* cache the data since it may be destroyed by subsequent * ipmi_xxx calls */ memcpy(id_buff, &rsp->data[3], 16); for (i=0; isendrecv(intf, &req); if (chk_rsp(rsp)) { return -1; } /* rsp->data[0] is equal to response data byte 2 in spec */ /* printf("Group Extension Identification: %02x\n", rsp->data[0]); */ memcpy(&val, rsp->data, sizeof (val)); t = val.time_stamp; gmtime_r(&t, &tm_t); printf("\n"); printf(" Instantaneous power reading: %8d Watts\n", val.curr_pwr); printf(" Minimum during sampling period: %8d Watts\n", val.min_sample); printf(" Maximum during sampling period: %8d Watts\n", val.max_sample); printf(" Average power reading over sample period: %8d Watts\n", val.avg_pwr); printf(" IPMI timestamp: %s", asctime(&tm_t)); printf(" Sampling period: %08d Milliseconds\n", val.sample); printf(" Power reading state is: "); /* mask the rsp->data so that we only care about bit 6 */ if((val.state & 0x40) == 0x40) { printf("activated"); } else { printf("deactivated"); } printf("\n\n"); return 0; } /* end Power Management get reading */ /* This is the get thermalpolicy command. * * @intf: ipmi interface handler */ int ipmi_dcmi_getthermalpolicy(struct ipmi_intf * intf, uint8_t entityID, uint8_t entityInstance) { struct ipmi_rs * rsp; struct ipmi_rq req; struct thermal_limit val; uint8_t msg_data[3]; /* number of request data bytes */ msg_data[0] = IPMI_DCMI; /* Group Extension Identification */ msg_data[1] = entityID; /* Inlet Temperature DCMI ID*/ msg_data[2] = entityInstance; /* Entity Instance */ memset(&req, 0, sizeof(req)); req.msg.netfn = IPMI_NETFN_DCGRP; req.msg.cmd = IPMI_DCMI_GETTERMALLIMIT; /* Get thermal policy reading */ req.msg.data = msg_data; /* msg_data above */ req.msg.data_len = 3; /* how many times does req.msg.data need to read */ rsp = intf->sendrecv(intf, &req); if (chk_rsp(rsp)) { return -1; } /* rsp->data[0] is equal to response data byte 2 in spec */ memcpy(&val, rsp->data, sizeof (val)); printf("\n"); printf(" Persistance flag is: %s\n", ((val.exceptionActions & 0x80) ? "set" : "notset")); printf(" Exception Actions, taken if the Temperature Limit exceeded:\n"); printf(" Hard Power Off system and log event: %s\n", ((val.exceptionActions & 0x40) ? "active":"inactive")); printf(" Log event to SEL only: %s\n", ((val.exceptionActions & 0x20) ? "active":"inactive")); printf(" Temperature Limit %d degrees\n", val.tempLimit); printf(" Exception Time %d seconds\n", val.exceptionTime); printf("\n\n"); return 0; } /* This is the set thermalpolicy command. * * @intf: ipmi interface handler */ int ipmi_dcmi_setthermalpolicy(struct ipmi_intf * intf, uint8_t entityID, uint8_t entityInst, uint8_t persistanceFlag, uint8_t actionHardPowerOff, uint8_t actionLogToSEL, uint8_t tempLimit, uint8_t samplingTimeLSB, uint8_t samplingTimeMSB) { struct ipmi_rs * rsp; struct ipmi_rq req; uint8_t msg_data[7]; /* number of request data bytes */ msg_data[0] = IPMI_DCMI; /* Group Extension Identification */ msg_data[1] = entityID; /* Inlet Temperature DCMI ID*/ msg_data[2] = entityInst; /* Entity Instance */ /* persistance and actions or disabled if no actions */ msg_data[3] = (((persistanceFlag ? 1 : 0) << 7) | ((actionHardPowerOff? 1 : 0) << 6) | ((actionLogToSEL ? 1 : 0) << 5)); msg_data[4] = tempLimit; msg_data[5] = samplingTimeLSB; msg_data[6] = samplingTimeMSB; memset(&req, 0, sizeof(req)); req.msg.netfn = IPMI_NETFN_DCGRP; /* Get thermal policy reading */ req.msg.cmd = IPMI_DCMI_SETTERMALLIMIT; req.msg.data = msg_data; /* msg_data above */ /* how many times does req.msg.data need to read */ req.msg.data_len = 7; rsp = intf->sendrecv(intf, &req); if (chk_rsp(rsp)) { return -1; } /* rsp->data[0] is equal to response data byte 2 in spec */ printf("\nThermal policy %d for %0Xh entity successfully set.\n\n", entityInst, entityID); return 0; } /* This is Get Temperature Readings Command * * returns ipmi response structure * * @intf: ipmi interface handler */ struct ipmi_rs * ipmi_dcmi_get_temp_readings(struct ipmi_intf * intf, uint8_t entityID, uint8_t entityInst, uint8_t entityInstStart) { struct ipmi_rq req; uint8_t msg_data[5]; /* number of request data bytes */ msg_data[0] = IPMI_DCMI; /* Group Extension Identification */ msg_data[1] = 0x01; /* Sensor type */ msg_data[2] = entityID; /* Entity Instance */ msg_data[3] = entityInst; msg_data[4] = entityInstStart; memset(&req, 0, sizeof(req)); req.msg.netfn = IPMI_NETFN_DCGRP; req.msg.cmd = IPMI_DCMI_GETTEMPRED; /* Get thermal policy reading */ req.msg.data = msg_data; /* msg_data above */ /* how many times does req.msg.data need to read */ req.msg.data_len = 5; return intf->sendrecv(intf, &req); } static int ipmi_dcmi_prnt_get_temp_readings(struct ipmi_intf * intf) { struct ipmi_rs * rsp; int i,j, tota_inst, get_inst, offset = 0; /* Print sensor description */ printf("\n\tEntity ID\t\t\tEntity Instance\t Temp. Readings"); for (i = 0; dcmi_temp_read_vals[i].str != NULL; i++) { /* get all of the information about this sensor */ rsp = ipmi_dcmi_get_temp_readings(intf, dcmi_temp_read_vals[i].val, 0, 0); if (chk_rsp(rsp)) { continue; } /* Total number of available instances for the Entity ID */ offset = 0; tota_inst = rsp->data[1]; while (tota_inst > 0) { get_inst = ((tota_inst / DCMI_MAX_BYTE_TEMP_READ_SIZE) ? DCMI_MAX_BYTE_TEMP_READ_SIZE : (tota_inst % DCMI_MAX_BYTE_TEMP_READ_SIZE)); rsp = ipmi_dcmi_get_temp_readings(intf, dcmi_temp_read_vals[i].val, offset, 0); if (chk_rsp(rsp)) { continue; } /* Number of sets of Temperature Data in this * response (Max 8 per response) */ for (j=0; j < rsp->data[2]*2; j=j+2) { /* Print Instance temperature info */ printf("\n%s",dcmi_temp_read_vals[i].desc); printf("\t\t%i\t\t%c%i C", rsp->data[j+4], ((rsp->data[j+3]) >> 7) ? '-' : '+', (rsp->data[j+3] & 127)); } offset += get_inst; tota_inst -= get_inst; } } return 0; } /* This is Get DCMI Config Parameters Command * * returns ipmi response structure * * @intf: ipmi interface handler */ struct ipmi_rs * ipmi_dcmi_getconfparam(struct ipmi_intf * intf, int param_selector) { struct ipmi_rq req; uint8_t msg_data[3]; /* number of request data bytes */ msg_data[0] = IPMI_DCMI; /* Group Extension Identification */ msg_data[1] = param_selector; /* Parameter selector */ /* Set Selector. Selects a given set of parameters under a given Parameter * selector value. 00h if parameter doesn't use a Set Selector. */ msg_data[2] = 0x00; memset(&req, 0, sizeof(req)); req.msg.netfn = IPMI_NETFN_DCGRP; req.msg.cmd = IPMI_DCMI_GETCONFPARAM; /* Get DCMI Config Parameters */ req.msg.data = msg_data; /* Contents above */ /* how many times does req.msg.data need to read */ req.msg.data_len = 3; return intf->sendrecv(intf, &req); } static int ipmi_dcmi_prnt_getconfparam(struct ipmi_intf * intf) { struct ipmi_rs * rsp; const int dcmi_conf_params = 5; int param_selector; uint16_t tmp_value = 0; /* We are not interested in parameter 1 which always will return 0 */ for (param_selector = 2 ; param_selector <= dcmi_conf_params; param_selector++) { rsp = ipmi_dcmi_getconfparam(intf, param_selector); if (chk_rsp(rsp)) { return -1; } /* Time to print what we have got */ switch(param_selector) { case 2: tmp_value = (rsp->data[4])& 1; printf("\n\tDHCP Discovery method\t: "); printf("\n\t\tManagement Controller ID String is %s", tmp_value ? "enabled" : "disabled"); printf("\n\t\tVendor class identifier DCMI IANA and Vendor class-specific Informationa are %s", ((rsp->data[4])& 2) ? "enabled" : "disabled" ); break; case 3: printf("\n\tInitial timeout interval\t: %i seconds", rsp->data[4]); break; case 4: printf("\n\tServer contact timeout interval\t: %i seconds", rsp->data[4] + (rsp->data[5]<<8)); break; case 5: printf("\n\tServer contact retry interval\t: %i seconds", rsp->data[4] + (rsp->data[5] << 8)); break; default: printf("\n\tConfiguration Parameter not supported."); } } return 0; } /* This is Set DCMI Config Parameters Command * * returns ipmi response structure * * @intf: ipmi interface handler */ struct ipmi_rs * ipmi_dcmi_setconfparam(struct ipmi_intf * intf, uint8_t param_selector, uint16_t value) { struct ipmi_rq req; uint8_t msg_data[5]; /* number of request data bytes */ msg_data[0] = IPMI_DCMI; /* Group Extension Identification */ msg_data[1] = param_selector; /* Parameter selector */ /* Set Selector (use 00h for parameters that only have one set). */ msg_data[2] = 0x00; if (param_selector > 3) { /* One bite more */ msg_data[3] = value & 0xFF; msg_data[4] = value >> 8; } else { msg_data[3] = value; } memset(&req, 0, sizeof(req)); req.msg.netfn = IPMI_NETFN_DCGRP; req.msg.cmd = IPMI_DCMI_SETCONFPARAM; /* Set DCMI Config Parameters */ req.msg.data = msg_data; /* Contents above */ if (param_selector > 3) { /* One bite more */ /* how many times does req.msg.data need to read */ req.msg.data_len = 5; } else { /* how many times does req.msg.data need to read */ req.msg.data_len = 4; } return intf->sendrecv(intf, &req); } /* Power Management get limit ipmi response * * This function returns the currently set power management settings as an * ipmi response structure. The reason it returns in the rsp struct is so * that it can be used in the set limit [slimit()] function to populate * un-changed or un-edited values. * * returns ipmi response structure * * @intf: ipmi interface handler */ struct ipmi_rs * ipmi_dcmi_pwr_glimit(struct ipmi_intf * intf) { struct ipmi_rq req; uint8_t msg_data[3]; /* number of request data bytes */ msg_data[0] = IPMI_DCMI; /* Group Extension Identification */ msg_data[1] = 0x00; /* reserved */ msg_data[2] = 0x00; /* reserved */ memset(&req, 0, sizeof(req)); req.msg.netfn = IPMI_NETFN_DCGRP; req.msg.cmd = IPMI_DCMI_GETLMT; /* Get power limit */ req.msg.data = msg_data; /* Contents above */ /* how many times does req.msg.data need to read */ req.msg.data_len = 3; return intf->sendrecv(intf, &req); } /* end Power Management get limit response */ /* Power Management print the get limit command * * This function calls the get limit function that returns an ipmi response. * * returns 0 else 1 with error * @intf: ipmi interface handler */ static int ipmi_dcmi_pwr_prnt_glimit(struct ipmi_intf * intf) { struct ipmi_rs * rsp; struct power_limit val; uint8_t realCc = 0xff; rsp = ipmi_dcmi_pwr_glimit(intf); /* rsp can be a null so check response before any operation * on it to avoid sig segv */ if (rsp != NULL) { realCc = rsp->ccode; GOOD_PWR_GLIMIT_CCODE(rsp->ccode); } if (chk_rsp(rsp)) { return -1; } /* rsp->data[0] is equal to response data byte 2 in spec */ /* printf("Group Extension Identification: %02x\n", rsp->data[0]); */ memcpy(&val, rsp->data, sizeof (val)); printf("\n Current Limit State: %s\n", (realCc == 0) ? "Power Limit Active" : "No Active Power Limit"); printf(" Exception actions: %s\n", val2str2(val.action, dcmi_pwrmgmt_get_action_vals)); printf(" Power Limit: %i Watts\n", val.limit); printf(" Correction time: %i milliseconds\n", val.correction); printf(" Sampling period: %i seconds\n", val.sample); printf("\n"); return 0; } /* end print get limit */ /* Power Management set limit * * Undocumented bounds: * Power limit: 0 - 0xFFFF * Correction period 5750ms to 28751ms or 0x1676 to 0x704F * sample period: 3 sec to 65 sec and 69+ * * @intf: ipmi interface handler * @option: Power option to change * @value: Value of the desired change */ static int ipmi_dcmi_pwr_slimit(struct ipmi_intf * intf, const char * option, const char * value) { struct ipmi_rs * rsp; /* ipmi response */ struct ipmi_rq req; /* ipmi request (to send) */ struct power_limit val; uint8_t msg_data[15]; /* number of request data bytes */ uint32_t lvalue = 0; int i; rsp = ipmi_dcmi_pwr_glimit(intf); /* get the power limit settings */ # if 0 { unsigned char counter = 0; printf("DATA (%d): ", rsp->data_len); for(counter = 0; counter < rsp->data_len; counter ++) { printf("%02X ", rsp->data[counter]); } printf("\n"); } # endif /* rsp can be a null so check response before any operation on it to * avoid sig segv */ if (rsp != NULL) { GOOD_PWR_GLIMIT_CCODE(rsp->ccode); } if (chk_rsp(rsp)) { return -1; } memcpy(&val, rsp->data, sizeof (val)); /* same as above; sets the values of the val struct * DCMI group ID * * val.grp_id = rsp->data[0]; * exception action * * val.action = rsp->data[3]; * * * power limit in Watts * * store 16 bits of the rsp from the 4th entity * * val.limit = *(uint16_t*)(&rsp->data[4]); * correction period in mS * * store 32 bits of the rsp from the 6th entity * * val.correction = *(uint32_t*)(&rsp->data[6]); * store 16 bits of the rsp from the 12th entity * * sample period in seconds * * val.sample = *(uint16_t*)(&rsp->data[12]); */ lprintf(LOG_INFO, "DCMI IN Limit=%d Correction=%d Action=%d Sample=%d\n", val.limit, val.correction, val.action, val.sample); switch (str2val2(option, dcmi_pwrmgmt_set_usage_vals)) { case 0x00: /* action */ switch (str2val2(value, dcmi_pwrmgmt_action_vals)) { case 0x00: /* no_action */ val.action = 0; break; case 0x01: /* power_off */ val.action = 1; break; case 0x02: /* OEM reserved action */ val.action = 0x02; break; case 0x03: /* OEM reserved action */ val.action = 0x03; break; case 0x04: /* OEM reserved action */ val.action = 0x04; break; case 0x05: /* OEM reserved action */ val.action = 0x05; break; case 0x06: /* OEM reserved action */ val.action = 0x06; break; case 0x07: /* OEM reserved action */ val.action = 0x07; break; case 0x08: /* OEM reserved action */ val.action = 0x08; break; case 0x09: /* OEM reserved action */ val.action = 0x09; break; case 0x0a: /* OEM reserved action */ val.action = 0x0a; break; case 0x0b: /* OEM reserved action */ val.action = 0x0b; break; case 0x0c: /* OEM reserved action */ val.action = 0x0c; break; case 0x0d: /* OEM reserved action */ val.action = 0x0d; break; case 0x0e: /* OEM reserved action */ val.action = 0x0e; break; case 0x0f: /* OEM reserved action */ val.action = 0x0f; break; case 0x10: /* OEM reserved action */ val.action = 0x10; break; case 0x11: /* sel_logging*/ val.action = 0x11; break; case 0xFF: /* error - not a string we knew what to do with */ lprintf(LOG_ERR, "Given %s '%s' is invalid.", option, value); return -1; } break; case 0x01: /* limit */ if (str2uint(value, &lvalue) != 0) { lprintf(LOG_ERR, "Given %s '%s' is invalid.", option, value); return (-1); } val.limit = *(uint16_t*)(&lvalue); break; case 0x02: /* correction */ if (str2uint(value, &lvalue) != 0) { lprintf(LOG_ERR, "Given %s '%s' is invalid.", option, value); return (-1); } val.correction = *(uint32_t*)(&lvalue); break; case 0x03: /* sample */ if (str2uint(value, &lvalue) != 0) { lprintf(LOG_ERR, "Given %s '%s' is invalid.", option, value); return (-1); } val.sample = *(uint16_t*)(&lvalue); break; case 0xff: /* no valid options */ return -1; } lprintf(LOG_INFO, "DCMI OUT Limit=%d Correction=%d Action=%d Sample=%d\n", val.limit, val.correction, val.action, val.sample); msg_data[0] = val.grp_id; /* Group Extension Identification */ msg_data[1] = 0x00; /* reserved */ msg_data[2] = 0x00; /* reserved */ msg_data[3] = 0x00; /* reserved */ msg_data[4] = val.action; /* exception action; 0x00 disables it */ /* fill msg_data[5] with the first 16 bits of val.limit */ *(uint16_t*)(&msg_data[5]) = val.limit; /* msg_data[5] = 0xFF; * msg_data[6] = 0xFF; */ /* fill msg_data[7] with the first 32 bits of val.correction */ *(uint32_t*)(&msg_data[7]) = val.correction; /* msg_data[7] = 0x76; * msg_data[8] = 0x16; * msg_data[9] = 0x00; * msg_data[10] = 0x00; */ msg_data[11] = 0x00; /* reserved */ msg_data[12] = 0x00; /* reserved */ /* fill msg_data[7] with the first 16 bits of val.sample */ *(uint16_t*)(&msg_data[13]) = val.sample; /* msg_data[13] = 0x03; */ memset(&req, 0, sizeof(req)); req.msg.netfn = IPMI_NETFN_DCGRP; req.msg.cmd = IPMI_DCMI_SETLMT; /* Set power limit */ req.msg.data = msg_data; /* Contents above */ /* how many times does req.msg.data need to read */ req.msg.data_len = 15; rsp = intf->sendrecv(intf, &req); if (chk_rsp(rsp)) { return -1; } return 0; } /* end Power Management set limit */ /* Power Management activate deactivate * * @intf: ipmi interface handler * @option: uint8_t - 0 to deactivate or 1 to activate */ static int ipmi_dcmi_pwr_actdeact(struct ipmi_intf * intf, uint8_t option) { struct ipmi_rs * rsp; struct ipmi_rq req; uint8_t msg_data[4]; /* number of request data bytes */ msg_data[0] = IPMI_DCMI; /* Group Extension Identification */ msg_data[1] = option; /* 0 = Deactivate 1 = Activate */ msg_data[2] = 0x00; /* reserved */ msg_data[3] = 0x00; /* reserved */ memset(&req, 0, sizeof(req)); req.msg.netfn = IPMI_NETFN_DCGRP; req.msg.cmd = IPMI_DCMI_PWRACT; /* Act-deactivate power limit */ req.msg.data = msg_data; /* Contents above */ req.msg.data_len = 4; /* how mant times does req.msg.data need to read */ rsp = intf->sendrecv(intf, &req); if (chk_rsp(rsp)) { return -1; } printf("\n Power limit successfully "); if (option == 0x00) { printf("deactivated"); } else { printf("activated"); } printf("\n"); return 0; } /* end power management activate/deactivate */ /* main * * @intf: dcmi interface handler * @argc: argument count * @argv: argument vector */ int ipmi_dcmi_main(struct ipmi_intf * intf, int argc, char **argv) { int rc = 0; uint8_t ctl = 0; int i, ii, instances; struct ipmi_rs *rsp; if ((argc == 0) || (strncmp(argv[0], "help", 4) == 0)) { print_strs(dcmi_cmd_vals, "Data Center Management Interface commands", -1, 0); return -1; } /* start the cmd requested */ switch (str2val2(argv[0], dcmi_cmd_vals)) { case 0x00: /* discover capabilities*/ for (i = 1; dcmi_capable_vals[i-1].str != NULL; i++) { if (ipmi_dcmi_prnt_getcapabilities(intf, i) < 0) { printf("Error discovering %s capabilities!\n", val2str2(i, dcmi_capable_vals)); return -1; } } break; case 0x01: /* power */ argv++; if (argv[0] == NULL) { print_strs(dcmi_pwrmgmt_vals, "power ", -1, 0); return -1; } /* power management */ switch (str2val2(argv[0], dcmi_pwrmgmt_vals)) { case 0x00: /* get reading */ rc = ipmi_dcmi_pwr_rd(intf); break; case 0x01: /* get limit */ /* because the get limit function is also used to * populate unchanged values for the set limit * command it returns an ipmi response structure */ rc = ipmi_dcmi_pwr_prnt_glimit(intf); break; case 0x02: /* set limit */ if (argc < 4) { print_strs(dcmi_pwrmgmt_set_usage_vals, "set_limit ", -1, 0); return -1; } if ( argc == 10) { /* Let`s initialize dcmi power parameters */ struct ipmi_rq req; uint8_t data[256]; uint16_t sample = 0; uint16_t limit = 0; uint32_t correction = 0; memset(data, 0, sizeof(data)); memset(&req, 0, sizeof(req)); req.msg.netfn = IPMI_NETFN_DCGRP; req.msg.lun = 0x00; req.msg.cmd = IPMI_DCMI_SETLMT; /* Set power limit */ req.msg.data = data; /* Contents above */ req.msg.data_len = 15; data[0] = IPMI_DCMI; /* Group Extension Identification */ data[1] = 0x0; /* reserved */ data[2] = 0x0; /* reserved */ data[3] = 0x0; /* reserved */ /* action */ switch (str2val2(argv[2], dcmi_pwrmgmt_action_vals)) { case 0x00: /* no_action */ data[4] = 0x00; break; case 0x01: /* power_off */ data[4] = 0x01; break; case 0x11: /* sel_logging*/ data[4] = 0x11; break; case 0xFF: /* error - not a string we knew what to do with */ lprintf(LOG_ERR, "Given Action '%s' is invalid.", argv[2]); return -1; } /* limit */ if (str2ushort(argv[4], &limit) != 0) { lprintf(LOG_ERR, "Given Limit '%s' is invalid.", argv[4]); return (-1); } data[5] = limit >> 0; data[6] = limit >> 8; /* correction */ if (str2uint(argv[6], &correction) != 0) { lprintf(LOG_ERR, "Given Correction '%s' is invalid.", argv[6]); return (-1); } data[7] = correction >> 0; data[8] = correction >> 8; data[9] = correction >> 16; data[10] = correction >> 24; data[11] = 0x00; /* reserved */ data[12] = 0x00; /* reserved */ /* sample */ if (str2ushort(argv[8], &sample) != 0) { lprintf(LOG_ERR, "Given Sample '%s' is invalid.", argv[8]); return (-1); } data[13] = sample >> 0; data[14] = sample >> 8; rsp = intf->sendrecv(intf, &req); if (chk_rsp(rsp)) { return -1; } } else { /* loop through each parameter and value until we have neither */ while ((argv[1] != NULL) && (argv[2] != NULL)) { rc = ipmi_dcmi_pwr_slimit(intf, argv[1], argv[2]); /* catch any error that the set limit function returned */ if (rc > 0) { print_strs(dcmi_pwrmgmt_set_usage_vals, "set_limit ", -1, 0); return -1; } /* the first argument is the command and the second is the * value. Move argv two places; what is now 3 will be 1 */ argv+=2; } } rc = ipmi_dcmi_pwr_prnt_glimit(intf); break; case 0x03: /* activate */ rc = ipmi_dcmi_pwr_actdeact(intf, 1); break; case 0x04: /* deactivate */ rc = ipmi_dcmi_pwr_actdeact(intf, 0); break; default: /* no valid options */ print_strs(dcmi_pwrmgmt_vals, "power ", -1, 0); break; } /* power mgmt end */ break; /* end power command */ case 0x02: /* sensor print */ /* Look for each item in the dcmi_discvry_snsr_vals struct * and if it exists, print the sdr record id(s) for it. * Use the val from each one as the sensor number. */ for (i = 0; dcmi_discvry_snsr_vals[i].str != NULL; i++) { /* get all of the information about this sensor */ rc = ipmi_dcmi_prnt_discvry_snsr(intf, dcmi_discvry_snsr_vals[i].val); } break; /* end sensor print */ case 0x03: /* asset tag */ if(ipmi_dcmi_prnt_getassettag(intf) < 0) { lprintf(LOG_ERR, "Error getting asset tag!"); return -1; } break; /* end asset tag */ case 0x04: { /* set asset tag */ if (argc == 1 ) { print_strs(dcmi_cmd_vals, "Data Center Management Interface commands", -1, 0); return -1; } if (ipmi_dcmi_prnt_setassettag(intf, argv[1]) < 0) { lprintf(LOG_ERR, "\nError setting asset tag!"); return -1; } break; } /* end set asset tag */ case 0x05: /* get management controller identifier string */ if (ipmi_dcmi_prnt_getmngctrlids(intf) < 0) { lprintf(LOG_ERR, "Error getting management controller identifier string!"); return -1; } break; /* end get management controller identifier string */ case 0x06: { /* set management controller identifier string */ if (argc == 1 ) { print_strs(dcmi_cmd_vals, "Data Center Management Interface commands", -1, 0); return -1; } if (ipmi_dcmi_prnt_setmngctrlids(intf, argv[1]) < 0) { lprintf(LOG_ERR, "Error setting management controller identifier string!"); return -1; } break; } /* end set management controller identifier string */ case 0x07: { uint8_t entityID = 0; uint8_t entityInst = 0; uint8_t persistanceFlag; uint8_t actionHardPowerOff; uint8_t actionLogToSEL; uint8_t tempLimit = 0; uint8_t samplingTimeLSB; uint8_t samplingTimeMSB; uint16_t samplingTime = 0; /* Thermal policy get/set */ /* dcmitool dcmi thermalpolicy get */ switch (str2val2(argv[1], dcmi_thermalpolicy_vals)) { case 0x00: if (argc < 4) { lprintf(LOG_NOTICE, "Get "); return -1; } if (str2uchar(argv[2], &entityID) != 0) { lprintf(LOG_ERR, "Given Entity ID '%s' is invalid.", argv[2]); return (-1); } if (str2uchar(argv[3], &entityInst) != 0) { lprintf(LOG_ERR, "Given Instance ID '%s' is invalid.", argv[3]); return (-1); } rc = ipmi_dcmi_getthermalpolicy(intf, entityID, entityInst); break; case 0x01: if (argc < 4) { lprintf(LOG_NOTICE, "Set "); return -1; } else if (argc < 9) { print_strs(dcmi_thermalpolicy_set_parameters_vals, "Set thermalpolicy instance parameters: " " " " " " ", -1, 0); return -1; } if (str2uchar(argv[2], &entityID) != 0) { lprintf(LOG_ERR, "Given Entity ID '%s' is invalid.", argv[2]); return (-1); } if (str2uchar(argv[3], &entityInst) != 0) { lprintf(LOG_ERR, "Given Instance ID '%s' is invalid.", argv[3]); return (-1); } persistanceFlag = (uint8_t) str2val2(argv[4], dcmi_thermalpolicy_set_parameters_vals); actionHardPowerOff = (uint8_t) str2val2(argv[5], dcmi_thermalpolicy_set_parameters_vals); actionLogToSEL = (uint8_t) str2val2(argv[6], dcmi_thermalpolicy_set_parameters_vals); if (str2uchar(argv[7], &tempLimit) != 0) { lprintf(LOG_ERR, "Given Temp Limit '%s' is invalid.", argv[7]); return (-1); } if (str2ushort(argv[8], &samplingTime) != 0) { lprintf(LOG_ERR, "Given Sampling Time '%s' is invalid.", argv[8]); return (-1); } samplingTimeLSB = (samplingTime & 0xFF); samplingTimeMSB = ((samplingTime & 0xFF00) >> 8); rc = ipmi_dcmi_setthermalpolicy(intf, entityID, entityInst, persistanceFlag, actionHardPowerOff, actionLogToSEL, tempLimit, samplingTimeLSB, samplingTimeMSB); break; default: print_strs(dcmi_thermalpolicy_vals, "thermalpolicy ", -1, 0); return -1; } break; } case 0x08: if(ipmi_dcmi_prnt_get_temp_readings(intf) < 0 ) { lprintf(LOG_ERR, "Error get temperature readings!"); } break; case 0x09: if(ipmi_dcmi_prnt_getconfparam(intf) < 0 ) { lprintf(LOG_ERR, "Error Get DCMI Configuration Parameters!"); }; break; case 0x0A: { switch (argc) { case 2: if (strncmp(argv[1], "activate_dhcp", 13) != 0) { print_strs( dcmi_conf_param_vals, "DCMI Configuration Parameters", -1, 0); return -1; } break; default: if (argc != 3 || strncmp(argv[1], "help", 4) == 0) { print_strs(dcmi_conf_param_vals, "DCMI Configuration Parameters", -1, 0); return -1; } } if (strncmp(argv[1], "activate_dhcp", 13) == 0) { rsp = ipmi_dcmi_setconfparam(intf, 1, 1); } else { uint16_t tmp_val = 0; if (str2ushort(argv[2], &tmp_val) != 0) { lprintf(LOG_ERR, "Given %s '%s' is invalid.", argv[1], argv[2]); return (-1); } rsp = ipmi_dcmi_setconfparam(intf, str2val2(argv[1], dcmi_conf_param_vals), tmp_val); } if (chk_rsp(rsp)) { lprintf(LOG_ERR, "Error Set DCMI Configuration Parameters!"); } break; } case 0x0B: { if (intf->session == NULL) { lprintf(LOG_ERR, "\nOOB discovery is available only via RMCP interface."); return -1; } if(ipmi_dcmi_prnt_oobDiscover(intf) < 0) { lprintf(LOG_ERR, "\nOOB discovering capabilities failed."); return -1; } break; } default: /* couldn't detect what the user entered */ print_strs(dcmi_cmd_vals, "Data Center Management Interface commands", -1, 0); return -1; break; } printf("\n"); return 0; } /* Display DCMI sensor information * Uses the ipmi_sdr_get_next_header to read SDR header and compare to the * target Record ID. Then either ipmi_sensor_print_full or * ipmi_sensor_print_compact is called to print the data * * @intf: ipmi interface handler * @rec_id: target Record ID */ static int ipmi_print_sensor_info(struct ipmi_intf *intf, uint16_t rec_id) { struct sdr_get_rs *header; struct ipmi_sdr_iterator *itr; int rc = 0; uint8_t *rec = NULL; itr = ipmi_sdr_start(intf, 0); if (itr == NULL) { lprintf(LOG_ERR, "Unable to open SDR for reading"); return (-1); } while ((header = ipmi_sdr_get_next_header(intf, itr)) != NULL) { if (header->id == rec_id) { break; } } if (header == NULL) { lprintf(LOG_DEBUG, "header == NULL"); ipmi_sdr_end(intf, itr); return (-1); } /* yes, we found the SDR for this record ID, now get full record */ rec = ipmi_sdr_get_record(intf, header, itr); if (rec == NULL) { lprintf(LOG_DEBUG, "rec == NULL"); ipmi_sdr_end(intf, itr); return (-1); } if ((header->type == SDR_RECORD_TYPE_FULL_SENSOR) || (header->type == SDR_RECORD_TYPE_COMPACT_SENSOR)) { rc = ipmi_sdr_print_rawentry(intf, header->type, rec, header->length); } else { rc = (-1); } free(rec); rec = NULL; ipmi_sdr_end(intf, itr); return rc; }