blob: fca9f278d66d400e76a81b41bd696753e9db4f98 [file] [log] [blame]
Matt Spinler1962e082020-08-05 13:44:53 -05001/**
2 * Copyright © 2020 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 "service_indicators.hpp"
17
Matt Spinler34a904c2020-08-05 14:53:28 -050018#include <fmt/format.h>
19
Matt Spinler05f0c6d2020-08-05 14:21:06 -050020#include <bitset>
Matt Spinler1962e082020-08-05 13:44:53 -050021#include <phosphor-logging/log.hpp>
22
23namespace openpower::pels::service_indicators
24{
25
26using namespace phosphor::logging;
27
Matt Spinler48c44db2020-08-25 12:47:13 -050028static constexpr auto platformSaiLedGroup =
29 "/xyz/openbmc_project/led/groups/platform_system_attention_indicator";
30
Matt Spinler1962e082020-08-05 13:44:53 -050031std::unique_ptr<Policy> getPolicy(const DataInterfaceBase& dataIface)
32{
33 // At the moment there is just one type of policy.
34 return std::make_unique<LightPath>(dataIface);
35}
36
37bool LightPath::ignore(const PEL& pel) const
38{
Matt Spinler05f0c6d2020-08-05 14:21:06 -050039 auto creator = pel.privateHeader().creatorID();
40
41 // Don't ignore serviceable BMC or hostboot errors
42 if ((static_cast<CreatorID>(creator) == CreatorID::openBMC) ||
43 (static_cast<CreatorID>(creator) == CreatorID::hostboot))
44 {
45 std::bitset<16> actionFlags{pel.userHeader().actionFlags()};
46 if (actionFlags.test(serviceActionFlagBit))
47 {
48 return false;
49 }
50 }
51
52 return true;
Matt Spinler1962e082020-08-05 13:44:53 -050053}
54
55void LightPath::activate(const PEL& pel)
56{
57 if (ignore(pel))
58 {
59 return;
60 }
61
62 // Now that we've gotten this far, we'll need to turn on
63 // the system attention indicator if we don't find other
64 // indicators to turn on.
65 bool sai = true;
66 auto src = pel.primarySRC();
67 const auto& calloutsObj = (*src)->callouts();
68
69 if (calloutsObj && !calloutsObj->callouts().empty())
70 {
71 const auto& callouts = calloutsObj->callouts();
72
73 // From the callouts, find the location codes whose
74 // LEDs need to be turned on.
75 auto locCodes = getLocationCodes(callouts);
76 if (!locCodes.empty())
77 {
Matt Spinler993168d2021-04-07 16:05:03 -050078 // Find the inventory paths for those location codes.
79 auto paths = getInventoryPaths(locCodes);
80 if (!paths.empty())
Matt Spinler1962e082020-08-05 13:44:53 -050081 {
Matt Spinler993168d2021-04-07 16:05:03 -050082 setNotFunctional(paths);
Sumit Kumar76198a22021-07-15 05:59:57 -050083 createCriticalAssociation(paths);
Matt Spinler1962e082020-08-05 13:44:53 -050084 sai = false;
85 }
86 }
87 }
88
89 if (sai)
90 {
Matt Spinler48c44db2020-08-25 12:47:13 -050091 try
92 {
93 _dataIface.assertLEDGroup(platformSaiLedGroup, true);
94 }
95 catch (const std::exception& e)
96 {
97 log<level::ERR>(
98 fmt::format("Failed to assert platform SAI LED group: {}",
99 e.what())
100 .c_str());
101 }
Matt Spinler1962e082020-08-05 13:44:53 -0500102 }
103}
104
105std::vector<std::string> LightPath::getLocationCodes(
106 const std::vector<std::unique_ptr<src::Callout>>& callouts) const
107{
Matt Spinler05f0c6d2020-08-05 14:21:06 -0500108 std::vector<std::string> locCodes;
109 bool firstCallout = true;
110 uint8_t firstCalloutPriority;
111
112 // Collect location codes for the first group of callouts,
113 // where a group can be:
114 // * a single medium priority callout
115 // * one or more high priority callouts
116 // * one or more medium group a priority callouts
117 //
118 // All callouts in the group must be hardware callouts.
119
120 for (const auto& callout : callouts)
121 {
122 if (firstCallout)
123 {
124 firstCallout = false;
125
126 firstCalloutPriority = callout->priority();
127
128 // If the first callout is High, Medium, or Medium
129 // group A, and is a hardware callout, then we
130 // want it.
131 if (isRequiredPriority(firstCalloutPriority) &&
132 isHardwareCallout(*callout))
133 {
134 locCodes.push_back(callout->locationCode());
135 }
136 else
137 {
138 break;
139 }
140
141 // By definition a medium priority callout can't be part
142 // of a group, so no need to look for more.
143 if (static_cast<CalloutPriority>(firstCalloutPriority) ==
144 CalloutPriority::medium)
145 {
146 break;
147 }
148 }
149 else
150 {
151 // Only continue while the callouts are the same
152 // priority as the first callout.
153 if (callout->priority() != firstCalloutPriority)
154 {
155 break;
156 }
157
158 // If any callout in the group isn't a hardware callout,
159 // then don't light up any LEDs at all.
160 if (!isHardwareCallout(*callout))
161 {
162 locCodes.clear();
163 break;
164 }
165
166 locCodes.push_back(callout->locationCode());
167 }
168 }
169
170 return locCodes;
171}
172
173bool LightPath::isRequiredPriority(uint8_t priority) const
174{
175 auto calloutPriority = static_cast<CalloutPriority>(priority);
176 return (calloutPriority == CalloutPriority::high) ||
177 (calloutPriority == CalloutPriority::medium) ||
178 (calloutPriority == CalloutPriority::mediumGroupA);
179}
180
181bool LightPath::isHardwareCallout(const src::Callout& callout) const
182{
183 const auto& fruIdentity = callout.fruIdentity();
184 if (fruIdentity)
185 {
186 return (callout.locationCodeSize() != 0) &&
187 ((fruIdentity->failingComponentType() ==
188 src::FRUIdentity::hardwareFRU) ||
189 (fruIdentity->failingComponentType() ==
190 src::FRUIdentity::symbolicFRUTrustedLocCode));
191 }
192
193 return false;
Matt Spinler1962e082020-08-05 13:44:53 -0500194}
195
Matt Spinler993168d2021-04-07 16:05:03 -0500196std::vector<std::string> LightPath::getInventoryPaths(
Matt Spinler1962e082020-08-05 13:44:53 -0500197 const std::vector<std::string>& locationCodes) const
198{
Matt Spinler993168d2021-04-07 16:05:03 -0500199 std::vector<std::string> paths;
Matt Spinler34a904c2020-08-05 14:53:28 -0500200 std::string inventoryPath;
201
202 for (const auto& locCode : locationCodes)
203 {
204 try
205 {
Matt Spinler993168d2021-04-07 16:05:03 -0500206 auto inventoryPath =
Matt Spinler34a904c2020-08-05 14:53:28 -0500207 _dataIface.getInventoryFromLocCode(locCode, 0, true);
Matt Spinler993168d2021-04-07 16:05:03 -0500208 paths.push_back(std::move(inventoryPath));
Matt Spinler34a904c2020-08-05 14:53:28 -0500209 }
210 catch (const std::exception& e)
211 {
212 log<level::ERR>(fmt::format("Could not get inventory path for "
213 "location code {} ({}).",
214 locCode, e.what())
215 .c_str());
216
Matt Spinler993168d2021-04-07 16:05:03 -0500217 // Unless we can set the LEDs for all FRUs, we can't turn
Matt Spinler34a904c2020-08-05 14:53:28 -0500218 // on any of them, so clear the list and quit.
Matt Spinler993168d2021-04-07 16:05:03 -0500219 paths.clear();
Matt Spinler34a904c2020-08-05 14:53:28 -0500220 break;
221 }
222 }
223
Matt Spinler993168d2021-04-07 16:05:03 -0500224 return paths;
Matt Spinler1962e082020-08-05 13:44:53 -0500225}
226
Matt Spinler993168d2021-04-07 16:05:03 -0500227void LightPath::setNotFunctional(
228 const std::vector<std::string>& inventoryPaths) const
Matt Spinler1962e082020-08-05 13:44:53 -0500229{
Matt Spinler993168d2021-04-07 16:05:03 -0500230 for (const auto& path : inventoryPaths)
Matt Spinler34a904c2020-08-05 14:53:28 -0500231 {
232 try
233 {
Matt Spinler993168d2021-04-07 16:05:03 -0500234 _dataIface.setFunctional(path, false);
Matt Spinler34a904c2020-08-05 14:53:28 -0500235 }
236 catch (const std::exception& e)
237 {
Matt Spinler993168d2021-04-07 16:05:03 -0500238 log<level::INFO>(
239 fmt::format("Could not write Functional property on {} ({})",
240 path, e.what())
241 .c_str());
Matt Spinler34a904c2020-08-05 14:53:28 -0500242 }
243 }
Matt Spinler1962e082020-08-05 13:44:53 -0500244}
245
Sumit Kumar76198a22021-07-15 05:59:57 -0500246void LightPath::createCriticalAssociation(
247 const std::vector<std::string>& inventoryPaths) const
248{
249 for (const auto& path : inventoryPaths)
250 {
251 try
252 {
253 _dataIface.setCriticalAssociation(path);
254 }
255 catch (const std::exception& e)
256 {
257 log<level::INFO>(
258 fmt::format(
259 "Could not set critical association on object path {} ({})",
260 path, e.what())
261 .c_str());
262 }
263 }
264}
265
Matt Spinler1962e082020-08-05 13:44:53 -0500266} // namespace openpower::pels::service_indicators