1 /** 2 * Copyright © 2019 IBM Corporation 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 #include "pel_values.hpp" 17 18 #include <algorithm> 19 #include <cassert> 20 21 namespace openpower 22 { 23 namespace pels 24 { 25 namespace pel_values 26 { 27 28 /** 29 * The possible values for the subsystem field in the User Header. 30 */ 31 const PELValues subsystemValues = { 32 {0x10, "processor", "Processor"}, 33 {0x11, "processor_fru", "Processor FRU"}, 34 {0x12, "processor_chip", "Processor Chip Cache"}, 35 {0x13, "processor_unit", "Processor Unit (CPU)"}, 36 {0x14, "processor_bus", "Processor Bus Controller"}, 37 38 {0x20, "memory", "Memory "}, 39 {0x21, "memory_ctlr", "Memory Controller"}, 40 {0x22, "memory_bus", "Memory Bus Interface"}, 41 {0x23, "memory_dimm", "Memory DIMM"}, 42 {0x24, "memory_fru", "Memory Card/FRU"}, 43 {0x25, "external_cache", "External Cache"}, 44 45 {0x30, "io", "I/O"}, 46 {0x31, "io_hub", "I/O Hub"}, 47 {0x32, "io_bridge", "I/O Bridge"}, 48 {0x33, "io_bus", "I/O bus interface"}, 49 {0x34, "io_processor", "I/O Processor"}, 50 {0x35, "io_hub_other", "SMA Hub"}, 51 {0x38, "phb", "PCI Bridge Chip"}, 52 53 {0x40, "io_adapter", "I/O Adapter"}, 54 {0x41, "io_adapter_comm", "I/O Adapter Communication"}, 55 {0x46, "io_device", "I/O Device"}, 56 {0x47, "io_device_dasd", "I/O Device Disk"}, 57 {0x4C, "io_external_general", "I/O External Peripheral"}, 58 {0x4D, "io_external_workstation", 59 "I/O External Peripheral Local Work Station"}, 60 {0x4E, "io_storage_mezz", "I/O Storage Mezza Expansion"}, 61 62 {0x50, "cec_hardware", "CEC Hardware"}, 63 {0x51, "cec_sp_a", "CEC Hardware - Service Processor A"}, 64 {0x52, "cec_sp_b", "CEC Hardware - Service Processor B"}, 65 {0x53, "cec_node_controller", "CEC Hardware - Node Controller"}, 66 {0x55, "cec_vpd", "CEC Hardware - VPD Interface"}, 67 {0x56, "cec_i2c", "CEC Hardware - I2C Devices"}, 68 {0x57, "cec_chip_iface", "CEC Hardware - CEC Chip Interface"}, 69 {0x58, "cec_clocks", "CEC Hardware - Clock"}, 70 {0x59, "cec_op_panel", "CEC Hardware - Operator Panel"}, 71 {0x5A, "cec_tod", "CEC Hardware - Time-Of-Day Hardware"}, 72 {0x5B, "cec_storage_device", "CEC Hardware - Memory Device"}, 73 {0x5C, "cec_sp_hyp_iface", 74 "CEC Hardware - Hypervisor<->Service Processor Interface"}, 75 {0x5D, "cec_service_network", "CEC Hardware - Service Network"}, 76 {0x5E, "cec_sp_hostboot_iface", 77 "CEC Hardware - Hostboot-Service Processor Interface"}, 78 79 {0x60, "power", "Power/Cooling"}, 80 {0x61, "power_supply", "Power Supply"}, 81 {0x62, "power_control_hw", "Power Control Hardware"}, 82 {0x63, "power_fans", "Fan (AMD)"}, 83 {0x64, "power_sequencer", "Digital Power Supply"}, 84 85 {0x70, "others", "Miscellaneous"}, 86 {0x71, "other_hmc", "HMC & Hardware"}, 87 {0x72, "other_test_tool", "Test Tool"}, 88 {0x73, "other_media", "Removable Media"}, 89 {0x74, "other_multiple_subsystems", "Multiple Subsystems"}, 90 {0x75, "other_na", "Not Applicable"}, 91 {0x76, "other_info_src", "Miscellaneous"}, 92 93 {0x7A, "surv_hyp_lost_sp", 94 "Hypervisor lost communication with service processor"}, 95 {0x7B, "surv_sp_lost_hyp", 96 "Service processor lost communication with Hypervisor"}, 97 {0x7C, "surv_sp_lost_hmc", "Service processor lost communication with HMC"}, 98 {0x7D, "surv_hmc_lost_lpar", 99 "HMC lost communication with logical partition"}, 100 {0x7E, "surv_hmc_lost_bpa", "HMC lost communication with BPA"}, 101 {0x7F, "surv_hmc_lost_hmc", "HMC lost communication with another HMC"}, 102 103 {0x80, "platform_firmware", "Platform Firmware"}, 104 {0x81, "sp_firmware", "Service Processor Firmware"}, 105 {0x82, "hyp_firmware", "System Hypervisor Firmware"}, 106 {0x83, "partition_firmware", "Partition Firmware"}, 107 {0x84, "slic_firmware", "SLIC Firmware"}, 108 {0x85, "spcn_firmware", "System Power Control Network Firmware"}, 109 {0x86, "bulk_power_firmware_side_a", "Bulk Power Firmware Side A"}, 110 {0x87, "hmc_code_firmware", "HMC Code"}, 111 {0x88, "bulk_power_firmware_side_b", "Bulk Power Firmware Side B"}, 112 {0x89, "virtual_sp", "Virtual Service Processor Firmware"}, 113 {0x8A, "hostboot", "HostBoot"}, 114 {0x8B, "occ", "OCC"}, 115 {0x8D, "bmc_firmware", "BMC Firmware"}, 116 117 {0x90, "software", "Software"}, 118 {0x91, "os_software", "Operating System software"}, 119 {0x92, "xpf_software", "XPF software"}, 120 {0x93, "app_software", "Application software"}, 121 122 {0xA0, "ext_env", "External Environment"}, 123 {0xA1, "input_power_source", "Input Power Source (ac)"}, 124 {0xA2, "ambient_temp", "Room Ambient Temperature"}, 125 {0xA3, "user_error", "User Error"}, 126 {0xA4, "corrosion", "Corrosion"}}; 127 128 /** 129 * The possible values for the severity field in the User Header. 130 */ 131 const PELValues severityValues = { 132 {0x00, "non_error", "Informational Event"}, 133 134 {0x10, "recovered", "Recovered Error"}, 135 {0x20, "predictive", "Predictive Error"}, 136 {0x21, "predictive_degraded_perf", 137 "Predictive Error, Degraded Performance"}, 138 {0x22, "predictive_reboot", "Predictive Error, Correctable"}, 139 {0x23, "predictive_reboot_degraded", 140 "Predictive Error, Correctable, Degraded"}, 141 {0x24, "predictive_redundancy_loss", "Predictive Error, Redundancy Lost"}, 142 143 {0x40, "unrecoverable", "Unrecoverable Error"}, 144 {0x41, "unrecoverable_degraded_perf", 145 "Unrecoverable Error, Degraded Performance"}, 146 {0x44, "unrecoverable_redundancy_loss", 147 "Unrecoverable Error, Loss of Redundancy"}, 148 {0x45, "unrecoverable_redundancy_loss_perf", 149 "Unrecoverable, Loss of Redundancy + Performance"}, 150 {0x48, "unrecoverable_loss_of_function", 151 "Unrecoverable Error, Loss of Function"}, 152 153 {0x50, "critical", "Critical Error, Scope of Failure unknown"}, 154 {0x51, "critical_system_term", "Critical Error, System Termination"}, 155 {0x52, "critical_imminent_failure", 156 "Critical Error, System Failure likely or imminent"}, 157 {0x53, "critical_partition_term", 158 "Critical Error, Partition(s) Termination"}, 159 {0x54, "critical_partition_imminent_failure", 160 "Critical Error, Partition(s) Failure likely or imminent"}, 161 162 {0x60, "diagnostic_error", "Error detected during diagnostic test"}, 163 {0x61, "diagnostic_error_incorrect_results", 164 "Diagostic error, resource w/incorrect results"}, 165 166 {0x71, "symptom_recovered", "Symptom Recovered"}, 167 {0x72, "symptom_predictive", "Symptom Predictive"}, 168 {0x74, "symptom_unrecoverable", "Symptom Unrecoverable"}, 169 {0x75, "symptom_critical", "Symptom Critical"}, 170 {0x76, "symptom_diag_err", "Symptom Diag Err"}}; 171 172 /** 173 * The possible values for the Event Type field in the User Header. 174 */ 175 const PELValues eventTypeValues = { 176 {0x00, "na", "Not Applicable"}, 177 {0x01, "misc_information_only", "Miscellaneous, Informational Only"}, 178 {0x02, "tracing_event", "Tracing Event"}, 179 {0x08, "dump_notification", "Dump Notification"}, 180 {0x30, "env_normal", "Customer environmental problem back to normal"}}; 181 182 /** 183 * The possible values for the Event Scope field in the User Header. 184 */ 185 const PELValues eventScopeValues = { 186 {0x01, "single_partition", "Single Partition"}, 187 {0x02, "multiple_partitions", "Multiple Partitions"}, 188 {0x03, "entire_platform", "Entire Platform"}, 189 {0x04, "possibly_multiple_platforms", "Multiple Platforms"}}; 190 191 /** 192 * The possible values for the Action Flags field in the User Header. 193 */ 194 const PELValues actionFlagsValues = { 195 {0x8000, "service_action", "Service Action Required"}, 196 {0x4000, "hidden", "Event not customer viewable"}, 197 {0x2000, "report", "Report Externally"}, 198 {0x1000, "dont_report", "Do Not Report To Hypervisor"}, 199 {0x0800, "call_home", "HMC Call Home"}, 200 {0x0400, "isolation_incomplete", 201 "Isolation Incomplete, further analysis required"}, 202 {0x0100, "termination", "Service Processor Call Home Required"}}; 203 204 /** 205 * The possible values for the Callout Priority field in the SRC. 206 */ 207 const PELValues calloutPriorityValues = { 208 {0x48, "high", "Mandatory, replace all with this type as a unit"}, 209 {0x4D, "medium", "Medium Priority"}, 210 {0x41, "medium_group_a", "Medium Priority A, replace these as a group"}, 211 {0x42, "medium_group_b", "Medium Priority B, replace these as a group"}, 212 {0x43, "medium_group_c", "Medium Priority C, replace these as a group"}, 213 {0x4C, "low", "Lowest priority replacement"}}; 214 215 /** 216 * @brief Map of the registry names for the maintenance procedures 217 * to their actual names. 218 */ 219 const std::map<std::string, std::string> maintenanceProcedures = { 220 {"bmc_code", "BMC0001"}, 221 // Isolation not possible, please contact your next level of support 222 {"next_level_support", "BMC0002"}, 223 // Problem is in SBE code, upgrade your firmware 224 {"sbe_code", "BMC0003"}, 225 // Problem is somewhere in the FSI bus path 226 {"fsi_path", "BMC0004"}, 227 // Problem is over-current PSU fault 228 {"power_overcurrent", "BMC0005"}, 229 // An unrecoverable event occurred, look for previous errors for the cause 230 {"find_sue_root_cause", "BMC0006"}, 231 }; 232 233 /** 234 * @brief Map of the registry names for the symbolic FRUs to their 235 * actual names. 236 */ 237 const std::map<std::string, std::string> symbolicFRUs = { 238 {"service_docs", "SVCDOCS"}, {"pwrsply", "PWRSPLY"}, 239 {"air_mover", "AIRMOVR"}, {"pgood_part", "PGDPART"}, 240 {"usb_pgood", "USBPGD"}, {"ambient_temp", "AMBTEMP"}, 241 {"ambient_temp_back", "AMBBACK"}, {"ambient_perf_loss", "AMBPERF"}, 242 {"ac_module", "ACMODUL"}, {"fan_cable", "FANCBL"}, 243 {"cable_continued", "CBLCONT"}, {"altitude", "ALTTUDE"}, 244 {"pcie_hot_plug", "PCIEHP"}, {"overtemp", "OVERTMP"}}; 245 246 PELValues::const_iterator findByValue(uint32_t value, const PELValues& fields) 247 { 248 return std::find_if(fields.begin(), fields.end(), 249 [value](const auto& entry) { 250 return value == std::get<fieldValuePos>(entry); 251 }); 252 } 253 254 PELValues::const_iterator findByName(const std::string& name, 255 const PELValues& fields) 256 257 { 258 return std::find_if(fields.begin(), fields.end(), 259 [&name](const auto& entry) { 260 return name == std::get<registryNamePos>(entry); 261 }); 262 } 263 264 /** 265 * @brief Map for section IDs 266 */ 267 const std::map<std::string, std::string> sectionTitles = { 268 {"PH", "Private Header"}, 269 {"UH", "User Header"}, 270 {"PS", "Primary SRC"}, 271 {"SS", "Secondary SRC"}, 272 {"EH", "Extended User Header"}, 273 {"MT", "Failing MTMS"}, 274 {"DH", "Dump Location"}, 275 {"SW", "Firmware Error"}, 276 {"LP", "Impacted Partition"}, 277 {"LR", "Logical Resource"}, 278 {"HM", "HMC ID"}, 279 {"EP", "EPOW"}, 280 {"IE", "IO Event"}, 281 {"MI", "MFG Info"}, 282 {"CH", "Call Home"}, 283 {"UD", "User Data"}, 284 {"EI", "Env Info"}, 285 {"ED", "Extended User Data"}}; 286 287 /** 288 * @brief Map for Procedure Descriptions 289 */ 290 const std::map<std::string, std::string> procedureDesc = {{"TODO", "TODO"}}; 291 292 /** 293 * @brief Map for Callout Failing Component Types 294 */ 295 const std::map<uint8_t, std::string> failingComponentType = { 296 {0x10, "Normal Hardware FRU"}, 297 {0x20, "Code FRU"}, 298 {0x30, "Configuration error, configuration procedure required"}, 299 {0x40, "Maintenance Procedure Required"}, 300 {0x90, "External FRU"}, 301 {0xA0, "External Code FRU"}, 302 {0xB0, "Tool FRU"}, 303 {0xC0, "Symbolic FRU"}, 304 {0xE0, "Symbolic FRU with trusted location code"}}; 305 306 /** 307 * @brief Map for Boolean value 308 */ 309 const std::map<bool, std::string> boolString = {{true, "True"}, 310 {false, "False"}}; 311 312 /** 313 * @brief Map for creator IDs 314 */ 315 const std::map<std::string, std::string> creatorIDs = { 316 317 {"O", "BMC"}, {"C", "HMC"}, {"H", "PHYP"}, {"L", "Partition FW"}, 318 {"S", "SLIC"}, {"B", "Hostboot"}, {"T", "OCC"}, {"M", "I/O Drawer"}, 319 {"K", "Sapphire"}, {"P", "PowerNV"}}; 320 321 /** 322 * @brief Map for transmission states 323 */ 324 const std::map<TransmissionState, std::string> transmissionStates = { 325 {TransmissionState::newPEL, "Not Sent"}, 326 {TransmissionState::badPEL, "Rejected"}, 327 {TransmissionState::sent, "Sent"}, 328 {TransmissionState::acked, "Acked"}}; 329 330 std::string getValue(const uint8_t field, const pel_values::PELValues& values, 331 const uint8_t position) 332 { 333 auto tmp = pel_values::findByValue(field, values); 334 if (tmp != values.end()) 335 { 336 if (position == pel_values::registryNamePos) 337 { 338 return std::get<pel_values::registryNamePos>(*tmp); 339 } 340 else 341 { 342 return std::get<pel_values::descriptionPos>(*tmp); 343 } 344 } 345 else 346 { 347 return "invalid"; 348 } 349 } 350 351 std::vector<std::string> getValuesBitwise(uint16_t value, 352 const pel_values::PELValues& table) 353 { 354 std::vector<std::string> foundValues; 355 std::for_each( 356 table.begin(), table.end(), [&value, &foundValues](const auto& entry) { 357 if (value & std::get<fieldValuePos>(entry)) 358 { 359 foundValues.push_back(std::get<descriptionPos>(entry)); 360 } 361 }); 362 return foundValues; 363 } 364 365 } // namespace pel_values 366 } // namespace pels 367 } // namespace openpower 368