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 Subsystem"},
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 Subsystem"},
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 Subsystem"},
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 Subsystem"},
54     {0x41, "io_adapter_comm", "I/O Adapter Communication"},
55     {0x46, "io_device", "I/O Device Subsystem"},
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 Subsystem"},
61 
62     {0x50, "cec_hardware", "CEC Hardware Subsystem"},
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 Subsystem"},
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 Subsystem"},
84 
85     {0x70, "others", "Miscellaneous"},
86     {0x71, "other_hmc", "HMC Subsystem & 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     {"no_vpd_for_fru", "BMCSP01"}, {"bmc_code", "BMCSP02"}};
221 
222 /**
223  * @brief Map of the registry names for the symbolic FRUs to their
224  *        actual names.
225  */
226 const std::map<std::string, std::string> symbolicFRUs = {
227     {"service_docs", "SVCDOCS"},      {"pwrsply", "PWRSPLY"},
228     {"air_mover", "AIRMOVR"},         {"pgood_part", "PGDPART"},
229     {"usb_pgood", "USBPGD"},          {"ambient_temp", "AMBTEMP"},
230     {"ambient_temp_back", "AMBBACK"}, {"ambient_perf_loss", "AMBPERF"},
231     {"ac_module", "ACMODUL"}};
232 
233 PELValues::const_iterator findByValue(uint32_t value, const PELValues& fields)
234 {
235     return std::find_if(fields.begin(), fields.end(),
236                         [value](const auto& entry) {
237                             return value == std::get<fieldValuePos>(entry);
238                         });
239 }
240 
241 PELValues::const_iterator findByName(const std::string& name,
242                                      const PELValues& fields)
243 
244 {
245     return std::find_if(fields.begin(), fields.end(),
246                         [&name](const auto& entry) {
247                             return name == std::get<registryNamePos>(entry);
248                         });
249 }
250 
251 /**
252  * @brief Map for section IDs
253  */
254 const std::map<std::string, std::string> sectionTitles = {
255     {"PH", "Private Header"},
256     {"UH", "User Header"},
257     {"PS", "Primary SRC"},
258     {"SS", "Secondary SRC"},
259     {"EH", "Extended User Header"},
260     {"MT", "Failing MTMS"},
261     {"DH", "Dump Location"},
262     {"SW", "Firmware Error"},
263     {"LP", "Impacted Partition"},
264     {"LR", "Logical Resource"},
265     {"HM", "HMC ID"},
266     {"EP", "EPOW"},
267     {"IE", "IO Event"},
268     {"MI", "MFG Info"},
269     {"CH", "Call Home"},
270     {"UD", "User Data"},
271     {"EI", "Env Info"},
272     {"ED", "Extended User Data"}};
273 
274 /**
275  * @brief Map for Procedure Descriptions
276  */
277 const std::map<std::string, std::string> procedureDesc = {{"TODO", "TODO"}};
278 
279 /**
280  * @brief Map for Callout Failing Component Types
281  */
282 const std::map<uint8_t, std::string> failingComponentType = {
283     {0x10, "Normal Hardware FRU"},
284     {0x20, "Code FRU"},
285     {0x30, "Configuration error, configuration procedure required"},
286     {0x40, "Maintenance Procedure Required"},
287     {0x90, "External FRU"},
288     {0xA0, "External Code FRU"},
289     {0xB0, "Tool FRU"},
290     {0xC0, "Symbolic FRU"},
291     {0xE0, "Symbolic FRU with trusted location code"}};
292 
293 /**
294  * @brief Map for Boolean value
295  */
296 const std::map<bool, std::string> boolString = {{true, "True"},
297                                                 {false, "False"}};
298 
299 /**
300  * @brief Map for creator IDs
301  */
302 const std::map<std::string, std::string> creatorIDs = {
303 
304     {"O", "BMC"},      {"C", "HMC"},      {"H", "PHYP"}, {"L", "Partition FW"},
305     {"S", "SLIC"},     {"B", "Hostboot"}, {"T", "OCC"},  {"M", "I/O Drawer"},
306     {"K", "Sapphire"}, {"P", "PowerNV"}};
307 
308 /**
309  * @brief Map for transmission states
310  */
311 const std::map<TransmissionState, std::string> transmissionStates = {
312     {TransmissionState::newPEL, "Not Sent"},
313     {TransmissionState::badPEL, "Rejected"},
314     {TransmissionState::sent, "Sent"},
315     {TransmissionState::acked, "Acked"}};
316 
317 std::string getValue(const uint8_t field, const pel_values::PELValues& values)
318 {
319 
320     auto tmp = pel_values::findByValue(field, values);
321     if (tmp != values.end())
322     {
323         return std::get<pel_values::descriptionPos>(*tmp);
324     }
325     else
326     {
327         return "invalid";
328     }
329 }
330 
331 std::vector<std::string> getValuesBitwise(uint16_t value,
332                                           const pel_values::PELValues& table)
333 {
334     std::vector<std::string> foundValues;
335     std::for_each(
336         table.begin(), table.end(), [&value, &foundValues](const auto& entry) {
337             if (value & std::get<fieldValuePos>(entry))
338             {
339                 foundValues.push_back(std::get<descriptionPos>(entry));
340             }
341         });
342     return foundValues;
343 }
344 
345 } // namespace pel_values
346 } // namespace pels
347 } // namespace openpower
348