blob: 1dcf46212d9516f9d4c23990edeadfbf9976a5b8 [file] [log] [blame]
Brandon Wyman24e422f2017-07-25 19:40:14 -05001/**
2 * Copyright © 2017 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 */
Brandon Wyman442035f2017-08-08 15:58:45 -050016#include <phosphor-logging/log.hpp>
17#include <phosphor-logging/elog.hpp>
Brandon Wymane0eb45c2017-10-06 12:58:42 -050018#include <org/open_power/Witherspoon/Fault/error.hpp>
Matt Spinlerceacf942017-10-05 13:55:02 -050019#include <xyz/openbmc_project/Common/Device/error.hpp>
Brandon Wyman442035f2017-08-08 15:58:45 -050020#include "elog-errors.hpp"
Brandon Wyman10295542017-08-09 18:20:44 -050021#include "names_values.hpp"
Brandon Wyman24e422f2017-07-25 19:40:14 -050022#include "power_supply.hpp"
Brandon Wyman442035f2017-08-08 15:58:45 -050023#include "pmbus.hpp"
24#include "utility.hpp"
25
26using namespace phosphor::logging;
Brandon Wymane0eb45c2017-10-06 12:58:42 -050027using namespace sdbusplus::org::open_power::Witherspoon::Fault::Error;
Matt Spinlerceacf942017-10-05 13:55:02 -050028using namespace sdbusplus::xyz::openbmc_project::Common::Device::Error;
Brandon Wyman24e422f2017-07-25 19:40:14 -050029
Brandon Wyman1db9a9e2017-07-26 18:50:22 -050030namespace witherspoon
Brandon Wyman24e422f2017-07-25 19:40:14 -050031{
32namespace power
33{
34namespace psu
35{
36
Brandon Wyman10295542017-08-09 18:20:44 -050037constexpr auto INVENTORY_OBJ_PATH = "/xyz/openbmc_project/inventory";
38constexpr auto INVENTORY_INTERFACE = "xyz.openbmc_project.Inventory.Item";
39constexpr auto PRESENT_PROP = "Present";
Brandon Wyman431fbe42017-08-18 16:22:09 -050040constexpr auto POWER_OBJ_PATH = "/org/openbmc/control/power0";
41constexpr auto POWER_INTERFACE = "org.openbmc.control.Power";
Brandon Wyman10295542017-08-09 18:20:44 -050042
43PowerSupply::PowerSupply(const std::string& name, size_t inst,
Brandon Wyman431fbe42017-08-18 16:22:09 -050044 const std::string& objpath,
45 const std::string& invpath,
46 sdbusplus::bus::bus& bus,
47 event::Event& e,
Brandon Wyman590fc282017-11-01 18:22:25 -050048 std::chrono::seconds& t,
49 std::chrono::seconds& p)
Brandon Wyman431fbe42017-08-18 16:22:09 -050050 : Device(name, inst), monitorPath(objpath), pmbusIntf(objpath),
Brandon Wyman50bb85d2017-11-01 18:36:00 -050051 inventoryPath(INVENTORY_OBJ_PATH + invpath), bus(bus), event(e),
52 presentInterval(p),
Brandon Wyman590fc282017-11-01 18:22:25 -050053 presentTimer(e, [this]()
54 {
55 this->present = true;
56 }),
57 powerOnInterval(t),
Brandon Wyman431fbe42017-08-18 16:22:09 -050058 powerOnTimer(e, [this]()
59 {
60 this->powerOn = true;
61 })
Brandon Wyman10295542017-08-09 18:20:44 -050062{
Brandon Wyman10295542017-08-09 18:20:44 -050063 using namespace sdbusplus::bus;
Brandon Wyman10295542017-08-09 18:20:44 -050064 presentMatch = std::make_unique<match_t>(bus,
65 match::rules::propertiesChanged(
Brandon Wyman50bb85d2017-11-01 18:36:00 -050066 inventoryPath,
Brandon Wyman10295542017-08-09 18:20:44 -050067 INVENTORY_INTERFACE),
68 [this](auto& msg)
Brandon Wyman431fbe42017-08-18 16:22:09 -050069 {
70 this->inventoryChanged(msg);
71 });
72 // Get initial presence state.
Brandon Wyman253dc9b2017-08-12 13:45:52 -050073 updatePresence();
Brandon Wyman431fbe42017-08-18 16:22:09 -050074
75 // Subscribe to power state changes
76 powerOnMatch = std::make_unique<match_t>(bus,
77 match::rules::propertiesChanged(
78 POWER_OBJ_PATH,
79 POWER_INTERFACE),
80 [this](auto& msg)
81 {
82 this->powerStateChanged(msg);
83 });
84 // Get initial power state.
85 updatePowerState();
Brandon Wyman10295542017-08-09 18:20:44 -050086}
Brandon Wyman442035f2017-08-08 15:58:45 -050087
Brandon Wymana1e96342017-09-25 16:47:44 -050088void PowerSupply::captureCmd(util::NamesValues& nv, const std::string& cmd,
89 witherspoon::pmbus::Type type)
90{
91 if (pmbusIntf.exists(cmd, type))
92 {
93 try
94 {
95 auto val = pmbusIntf.read(cmd, type);
96 nv.add(cmd, val);
97 }
98 catch (std::exception& e)
99 {
100 log<level::INFO>("Unable to capture metadata", entry("CMD=%s",
101 cmd));
102 }
103 }
104}
Brandon Wyman431fbe42017-08-18 16:22:09 -0500105
Brandon Wyman1db9a9e2017-07-26 18:50:22 -0500106void PowerSupply::analyze()
107{
Brandon Wyman442035f2017-08-08 15:58:45 -0500108 using namespace witherspoon::pmbus;
109
110 try
111 {
Brandon Wyman10295542017-08-09 18:20:44 -0500112 if (present)
Brandon Wyman442035f2017-08-08 15:58:45 -0500113 {
Brandon Wyman764c7972017-08-22 17:05:36 -0500114 std::uint16_t statusWord = 0;
Brandon Wyman764c7972017-08-22 17:05:36 -0500115
116 // Read the 2 byte STATUS_WORD value to check for faults.
117 statusWord = pmbusIntf.read(STATUS_WORD, Type::Debug);
Brandon Wymane4af9802017-11-13 15:58:33 -0600118 readFail = 0;
Brandon Wyman764c7972017-08-22 17:05:36 -0500119
Brandon Wymanbee81612017-11-01 18:24:43 -0500120 //TODO: openbmc/openbmc#2484 Three consecutive reads should be
121 // performed.
Brandon Wyman10295542017-08-09 18:20:44 -0500122 // If 3 consecutive reads are seen, log the fault.
123 // Driver gives cached value, read once a second.
124 // increment for fault on, decrement for fault off, to deglitch.
125 // If count reaches 3, we have fault. If count reaches 0, fault is
126 // cleared.
127
Brandon Wyman603cc002017-08-28 18:17:58 -0500128 checkInputFault(statusWord);
Brandon Wyman764c7972017-08-22 17:05:36 -0500129
Brandon Wyman3343e822017-11-03 16:54:11 -0500130 if (powerOn && !faultFound)
Brandon Wyman764c7972017-08-22 17:05:36 -0500131 {
Brandon Wyman12661f12017-08-31 15:28:21 -0500132 checkFanFault(statusWord);
Brandon Wyman875b3632017-09-13 18:46:03 -0500133 checkTemperatureFault(statusWord);
Brandon Wymancfa032b2017-09-25 17:37:50 -0500134 checkOutputOvervoltageFault(statusWord);
135 checkCurrentOutOverCurrentFault(statusWord);
136 checkPGOrUnitOffFault(statusWord);
Brandon Wyman442035f2017-08-08 15:58:45 -0500137 }
138 }
139 }
140 catch (ReadFailure& e)
141 {
Brandon Wymane4af9802017-11-13 15:58:33 -0600142 if (readFail < FAULT_COUNT)
143 {
144 readFail++;
145 }
146
147 if (!readFailLogged && readFail >= FAULT_COUNT)
Brandon Wyman442035f2017-08-08 15:58:45 -0500148 {
149 commit<ReadFailure>();
150 readFailLogged = true;
Brandon Wyman442035f2017-08-08 15:58:45 -0500151 }
152 }
153
Brandon Wyman1db9a9e2017-07-26 18:50:22 -0500154 return;
155}
156
Brandon Wyman10295542017-08-09 18:20:44 -0500157void PowerSupply::inventoryChanged(sdbusplus::message::message& msg)
158{
159 std::string msgSensor;
160 std::map<std::string, sdbusplus::message::variant<uint32_t, bool>> msgData;
161 msg.read(msgSensor, msgData);
162
163 // Check if it was the Present property that changed.
164 auto valPropMap = msgData.find(PRESENT_PROP);
165 if (valPropMap != msgData.end())
166 {
167 present = sdbusplus::message::variant_ns::get<bool>(valPropMap->second);
168
169 if (present)
170 {
Brandon Wyman6ccce0b2017-10-26 15:13:10 -0500171 clearFaults();
Brandon Wyman590fc282017-11-01 18:22:25 -0500172 presentTimer.start(presentInterval, Timer::TimerType::oneshot);
173 }
174 else
175 {
176 presentTimer.stop();
Brandon Wyman10295542017-08-09 18:20:44 -0500177 }
178 }
179
180 return;
181}
182
183void PowerSupply::updatePresence()
184{
185 // Use getProperty utility function to get presence status.
Brandon Wyman10295542017-08-09 18:20:44 -0500186 std::string service = "xyz.openbmc_project.Inventory.Manager";
Brandon Wyman50bb85d2017-11-01 18:36:00 -0500187 util::getProperty(INVENTORY_INTERFACE, PRESENT_PROP, inventoryPath,
188 service, bus, this->present);
Brandon Wyman10295542017-08-09 18:20:44 -0500189}
190
Brandon Wyman431fbe42017-08-18 16:22:09 -0500191void PowerSupply::powerStateChanged(sdbusplus::message::message& msg)
192{
193 int32_t state = 0;
194 std::string msgSensor;
195 std::map<std::string, sdbusplus::message::variant<int32_t, int32_t>>
196 msgData;
197 msg.read(msgSensor, msgData);
198
199 // Check if it was the Present property that changed.
200 auto valPropMap = msgData.find("state");
201 if (valPropMap != msgData.end())
202 {
203 state = sdbusplus::message::variant_ns::get<int32_t>(valPropMap->second);
204
205 // Power is on when state=1. Set the fault logged variables to false
206 // and start the power on timer when the state changes to 1.
207 if (state)
208 {
Brandon Wyman6ccce0b2017-10-26 15:13:10 -0500209 clearFaults();
Brandon Wyman431fbe42017-08-18 16:22:09 -0500210 powerOnTimer.start(powerOnInterval, Timer::TimerType::oneshot);
211 }
212 else
213 {
214 powerOnTimer.stop();
215 powerOn = false;
216 }
217 }
218
219}
220
221void PowerSupply::updatePowerState()
222{
223 // When state = 1, system is powered on
224 int32_t state = 0;
225
226 try
227 {
228 auto service = util::getService(POWER_OBJ_PATH,
229 POWER_INTERFACE,
230 bus);
231
232 // Use getProperty utility function to get power state.
233 util::getProperty<int32_t>(POWER_INTERFACE,
234 "state",
235 POWER_OBJ_PATH,
236 service,
237 bus,
238 state);
239
240 if (state)
241 {
242 powerOn = true;
243 }
244 else
245 {
246 powerOn = false;
247 }
248 }
249 catch (std::exception& e)
250 {
251 log<level::INFO>("Failed to get power state. Assuming it is off.");
252 powerOn = false;
253 }
254
255}
256
Brandon Wyman603cc002017-08-28 18:17:58 -0500257void PowerSupply::checkInputFault(const uint16_t statusWord)
258{
259 using namespace witherspoon::pmbus;
260
Brandon Wymana3c675c2017-11-14 14:54:54 -0600261 if ((inputFault < FAULT_COUNT) &&
262 ((statusWord & status_word::INPUT_FAULT_WARN) ||
263 (statusWord & status_word::VIN_UV_FAULT)))
Brandon Wyman603cc002017-08-28 18:17:58 -0500264 {
Brandon Wymana3c675c2017-11-14 14:54:54 -0600265 inputFault++;
Brandon Wyman603cc002017-08-28 18:17:58 -0500266 }
267 else
268 {
Brandon Wymana3c675c2017-11-14 14:54:54 -0600269 if ((inputFault > 0) &&
Brandon Wymand20686a2017-11-01 17:45:23 -0500270 !(statusWord & status_word::INPUT_FAULT_WARN) &&
271 !(statusWord & status_word::VIN_UV_FAULT))
Brandon Wyman603cc002017-08-28 18:17:58 -0500272 {
Brandon Wymana3c675c2017-11-14 14:54:54 -0600273 inputFault = 0;
Brandon Wyman3343e822017-11-03 16:54:11 -0500274 faultFound = false;
Brandon Wyman69591bd2017-11-01 18:07:23 -0500275
Brandon Wyman603cc002017-08-28 18:17:58 -0500276 log<level::INFO>("INPUT_FAULT_WARN cleared",
Brandon Wymana3c675c2017-11-14 14:54:54 -0600277 entry("POWERSUPPLY=%s", inventoryPath.c_str()));
Brandon Wyman69591bd2017-11-01 18:07:23 -0500278
279 if (powerOn)
280 {
281 // The power supply will not be immediately powered on after
282 // the input power is restored.
283 powerOn = false;
284 // Start up the timer that will set the state to indicate we
285 // are ready for the powered on fault checks.
286 powerOnTimer.start(powerOnInterval, Timer::TimerType::oneshot);
287 }
Brandon Wyman603cc002017-08-28 18:17:58 -0500288 }
289 }
Brandon Wymana3c675c2017-11-14 14:54:54 -0600290
291 if (!faultFound && (inputFault >= FAULT_COUNT))
292 {
293 util::NamesValues nv;
294 nv.add("STATUS_WORD", statusWord);
295 captureCmd(nv, STATUS_INPUT, Type::Debug);
296
297 using metadata = org::open_power::Witherspoon::Fault::
298 PowerSupplyInputFault;
299
300 report<PowerSupplyInputFault>(
301 metadata::RAW_STATUS(nv.get().c_str()),
302 metadata::CALLOUT_INVENTORY_PATH(inventoryPath.c_str()));
303 faultFound = true;
304 }
305
Brandon Wyman603cc002017-08-28 18:17:58 -0500306}
307
308void PowerSupply::checkPGOrUnitOffFault(const uint16_t statusWord)
309{
310 using namespace witherspoon::pmbus;
311
Brandon Wyman593d24f2017-10-13 18:15:23 -0500312 if (powerOnFault < FAULT_COUNT)
Brandon Wyman603cc002017-08-28 18:17:58 -0500313 {
Brandon Wyman593d24f2017-10-13 18:15:23 -0500314 // Check PG# and UNIT_IS_OFF
315 if ((statusWord & status_word::POWER_GOOD_NEGATED) ||
316 (statusWord & status_word::UNIT_IS_OFF))
317 {
318 log<level::INFO>("PGOOD or UNIT_IS_OFF bit bad",
319 entry("STATUS_WORD=0x%04X", statusWord));
320 powerOnFault++;
321 }
322 else
323 {
324 if (powerOnFault > 0)
325 {
326 log<level::INFO>("PGOOD and UNIT_IS_OFF bits good");
327 powerOnFault = 0;
328 }
329 }
Brandon Wyman603cc002017-08-28 18:17:58 -0500330
Brandon Wyman593d24f2017-10-13 18:15:23 -0500331 if (powerOnFault >= FAULT_COUNT)
332 {
Brandon Wyman3343e822017-11-03 16:54:11 -0500333 faultFound = true;
334
Brandon Wyman593d24f2017-10-13 18:15:23 -0500335 util::NamesValues nv;
336 nv.add("STATUS_WORD", statusWord);
337 captureCmd(nv, STATUS_INPUT, Type::Debug);
338 auto status0Vout = pmbusIntf.insertPageNum(STATUS_VOUT, 0);
339 captureCmd(nv, status0Vout, Type::Debug);
340 captureCmd(nv, STATUS_IOUT, Type::Debug);
341 captureCmd(nv, STATUS_MFR, Type::Debug);
Brandon Wyman603cc002017-08-28 18:17:58 -0500342
Brandon Wyman593d24f2017-10-13 18:15:23 -0500343 using metadata = org::open_power::Witherspoon::Fault::
344 PowerSupplyShouldBeOn;
Brandon Wyman603cc002017-08-28 18:17:58 -0500345
Brandon Wyman593d24f2017-10-13 18:15:23 -0500346 // A power supply is OFF (or pgood low) but should be on.
347 report<PowerSupplyShouldBeOn>(
348 metadata::RAW_STATUS(nv.get().c_str()),
349 metadata::CALLOUT_INVENTORY_PATH(
350 inventoryPath.c_str()));
351 }
Brandon Wyman603cc002017-08-28 18:17:58 -0500352 }
353
354}
355
356void PowerSupply::checkCurrentOutOverCurrentFault(const uint16_t statusWord)
357{
358 using namespace witherspoon::pmbus;
359
Brandon Wymandd61be42017-11-07 18:38:54 -0600360 if (outputOCFault < FAULT_COUNT)
Brandon Wyman603cc002017-08-28 18:17:58 -0500361 {
Brandon Wymandd61be42017-11-07 18:38:54 -0600362 // Check for an output overcurrent fault.
363 if ((statusWord & status_word::IOUT_OC_FAULT))
364 {
365 outputOCFault++;
366 }
367 else
368 {
369 if (outputOCFault > 0)
370 {
371 outputOCFault = 0;
372 }
373 }
Brandon Wyman603cc002017-08-28 18:17:58 -0500374
Brandon Wymandd61be42017-11-07 18:38:54 -0600375 if (outputOCFault >= FAULT_COUNT)
376 {
377 util::NamesValues nv;
378 nv.add("STATUS_WORD", statusWord);
379 captureCmd(nv, STATUS_INPUT, Type::Debug);
380 auto status0Vout = pmbusIntf.insertPageNum(STATUS_VOUT, 0);
381 captureCmd(nv, status0Vout, Type::Debug);
382 captureCmd(nv, STATUS_IOUT, Type::Debug);
383 captureCmd(nv, STATUS_MFR, Type::Debug);
Brandon Wyman603cc002017-08-28 18:17:58 -0500384
Brandon Wymandd61be42017-11-07 18:38:54 -0600385 using metadata = org::open_power::Witherspoon::Fault::
386 PowerSupplyOutputOvercurrent;
Brandon Wyman603cc002017-08-28 18:17:58 -0500387
Brandon Wymandd61be42017-11-07 18:38:54 -0600388 report<PowerSupplyOutputOvercurrent>(
389 metadata::RAW_STATUS(nv.get().c_str()),
390 metadata::CALLOUT_INVENTORY_PATH(inventoryPath.c_str()));
391
392 faultFound = true;
393 }
Brandon Wyman603cc002017-08-28 18:17:58 -0500394 }
395}
396
Brandon Wymanab05c072017-08-30 18:26:41 -0500397void PowerSupply::checkOutputOvervoltageFault(const uint16_t statusWord)
398{
399 using namespace witherspoon::pmbus;
400
Brandon Wyman2ab319b2017-11-08 17:34:59 -0600401 if (outputOVFault < FAULT_COUNT)
Brandon Wymanab05c072017-08-30 18:26:41 -0500402 {
Brandon Wyman2ab319b2017-11-08 17:34:59 -0600403 // Check for an output overvoltage fault.
404 if (statusWord & status_word::VOUT_OV_FAULT)
405 {
406 outputOVFault++;
407 }
408 else
409 {
410 if (outputOVFault > 0)
411 {
412 outputOVFault = 0;
413 }
414 }
Brandon Wymanab05c072017-08-30 18:26:41 -0500415
Brandon Wyman2ab319b2017-11-08 17:34:59 -0600416 if (outputOVFault >= FAULT_COUNT)
417 {
418 util::NamesValues nv;
419 nv.add("STATUS_WORD", statusWord);
420 captureCmd(nv, STATUS_INPUT, Type::Debug);
421 auto status0Vout = pmbusIntf.insertPageNum(STATUS_VOUT, 0);
422 captureCmd(nv, status0Vout, Type::Debug);
423 captureCmd(nv, STATUS_IOUT, Type::Debug);
424 captureCmd(nv, STATUS_MFR, Type::Debug);
Brandon Wymanab05c072017-08-30 18:26:41 -0500425
Brandon Wyman2ab319b2017-11-08 17:34:59 -0600426 using metadata = org::open_power::Witherspoon::Fault::
427 PowerSupplyOutputOvervoltage;
Brandon Wymanab05c072017-08-30 18:26:41 -0500428
Brandon Wyman2ab319b2017-11-08 17:34:59 -0600429 report<PowerSupplyOutputOvervoltage>(
430 metadata::RAW_STATUS(nv.get().c_str()),
431 metadata::CALLOUT_INVENTORY_PATH(inventoryPath.c_str()));
432
433 faultFound = true;
434 }
Brandon Wymanab05c072017-08-30 18:26:41 -0500435 }
436}
437
Brandon Wyman12661f12017-08-31 15:28:21 -0500438void PowerSupply::checkFanFault(const uint16_t statusWord)
439{
440 using namespace witherspoon::pmbus;
441
Brandon Wymanba255532017-11-08 17:44:10 -0600442 if (fanFault < FAULT_COUNT)
Brandon Wyman12661f12017-08-31 15:28:21 -0500443 {
Brandon Wymanba255532017-11-08 17:44:10 -0600444 // Check for a fan fault or warning condition
445 if (statusWord & status_word::FAN_FAULT)
446 {
447 fanFault++;
448 }
449 else
450 {
451 if (fanFault > 0)
452 {
453 fanFault = 0;
454 }
455 }
Brandon Wyman12661f12017-08-31 15:28:21 -0500456
Brandon Wymanba255532017-11-08 17:44:10 -0600457 if (fanFault >= FAULT_COUNT)
458 {
459 util::NamesValues nv;
460 nv.add("STATUS_WORD", statusWord);
461 captureCmd(nv, STATUS_MFR, Type::Debug);
462 captureCmd(nv, STATUS_TEMPERATURE, Type::Debug);
463 captureCmd(nv, STATUS_FANS_1_2, Type::Debug);
Brandon Wyman12661f12017-08-31 15:28:21 -0500464
Brandon Wymanba255532017-11-08 17:44:10 -0600465 using metadata = org::open_power::Witherspoon::Fault::
466 PowerSupplyFanFault;
Brandon Wyman12661f12017-08-31 15:28:21 -0500467
Brandon Wymanba255532017-11-08 17:44:10 -0600468 report<PowerSupplyFanFault>(
469 metadata::RAW_STATUS(nv.get().c_str()),
470 metadata::CALLOUT_INVENTORY_PATH(inventoryPath.c_str()));
471
472 faultFound = true;
473 }
Brandon Wyman12661f12017-08-31 15:28:21 -0500474 }
475}
476
Brandon Wyman875b3632017-09-13 18:46:03 -0500477void PowerSupply::checkTemperatureFault(const uint16_t statusWord)
478{
479 using namespace witherspoon::pmbus;
480
481 // Due to how the PMBus core device driver sends a clear faults command
482 // the bit in STATUS_WORD will likely be cleared when we attempt to examine
483 // it for a Thermal Fault or Warning. So, check the STATUS_WORD and the
484 // STATUS_TEMPERATURE bits. If either indicates a fault, proceed with
485 // logging the over-temperature condition.
486 std::uint8_t statusTemperature = 0;
487 statusTemperature = pmbusIntf.read(STATUS_TEMPERATURE, Type::Debug);
Brandon Wyman50044ea2017-11-08 17:58:56 -0600488 if (temperatureFault < FAULT_COUNT)
Brandon Wyman875b3632017-09-13 18:46:03 -0500489 {
Brandon Wyman50044ea2017-11-08 17:58:56 -0600490 if ((statusWord & status_word::TEMPERATURE_FAULT_WARN) ||
491 (statusTemperature & status_temperature::OT_FAULT))
492 {
493 temperatureFault++;
494 }
495 else
496 {
497 if (temperatureFault > 0)
498 {
499 temperatureFault = 0;
500 }
501 }
Brandon Wyman875b3632017-09-13 18:46:03 -0500502
Brandon Wyman50044ea2017-11-08 17:58:56 -0600503 if (temperatureFault >= FAULT_COUNT)
504 {
505 // The power supply has had an over-temperature condition.
506 // This may not result in a shutdown if experienced for a short
507 // duration.
508 // This should not occur under normal conditions.
509 // The power supply may be faulty, or the paired supply may be
510 // putting out less current.
511 // Capture command responses with potentially relevant information,
512 // and call out the power supply reporting the condition.
513 util::NamesValues nv;
514 nv.add("STATUS_WORD", statusWord);
515 captureCmd(nv, STATUS_MFR, Type::Debug);
516 captureCmd(nv, STATUS_IOUT, Type::Debug);
517 nv.add("STATUS_TEMPERATURE", statusTemperature);
518 captureCmd(nv, STATUS_FANS_1_2, Type::Debug);
Brandon Wyman875b3632017-09-13 18:46:03 -0500519
Brandon Wyman50044ea2017-11-08 17:58:56 -0600520 using metadata = org::open_power::Witherspoon::Fault::
521 PowerSupplyTemperatureFault;
Brandon Wyman875b3632017-09-13 18:46:03 -0500522
Brandon Wyman50044ea2017-11-08 17:58:56 -0600523 report<PowerSupplyTemperatureFault>(
524 metadata::RAW_STATUS(nv.get().c_str()),
525 metadata::CALLOUT_INVENTORY_PATH(inventoryPath.c_str()));
526
527 faultFound = true;
528 }
Brandon Wyman875b3632017-09-13 18:46:03 -0500529 }
530}
531
Brandon Wyman1db9a9e2017-07-26 18:50:22 -0500532void PowerSupply::clearFaults()
533{
Brandon Wymane4af9802017-11-13 15:58:33 -0600534 readFail = 0;
Brandon Wyman6ccce0b2017-10-26 15:13:10 -0500535 readFailLogged = false;
Brandon Wymana3c675c2017-11-14 14:54:54 -0600536 inputFault = 0;
Brandon Wyman6ccce0b2017-10-26 15:13:10 -0500537 powerOnFault = 0;
Brandon Wymandd61be42017-11-07 18:38:54 -0600538 outputOCFault = 0;
Brandon Wyman2ab319b2017-11-08 17:34:59 -0600539 outputOVFault = 0;
Brandon Wymanba255532017-11-08 17:44:10 -0600540 fanFault = 0;
Brandon Wyman50044ea2017-11-08 17:58:56 -0600541 temperatureFault = 0;
Brandon Wyman3343e822017-11-03 16:54:11 -0500542 faultFound = false;
Brandon Wyman6ccce0b2017-10-26 15:13:10 -0500543
Brandon Wyman1db9a9e2017-07-26 18:50:22 -0500544 return;
545}
546
Brandon Wyman24e422f2017-07-25 19:40:14 -0500547}
548}
549}