pseq: Create UCD90xDevice class
Create the UCD90xDevice class in the phosphor-power-sequencer
application.
This is a base class for the UCD90x family of power sequencer devices.
Tested:
* Performed the following tests on Rainier and Everest systems
* MFR_STATUS value obtained successfully
* Verified error paths and exceptions thrown
Change-Id: I430ffb95d96e228ce0245ae1c9cb63db72d590c5
Signed-off-by: Shawn McCarney <shawnmm@us.ibm.com>
diff --git a/phosphor-power-sequencer/test/meson.build b/phosphor-power-sequencer/test/meson.build
index 2a15f0a..b915859 100644
--- a/phosphor-power-sequencer/test/meson.build
+++ b/phosphor-power-sequencer/test/meson.build
@@ -6,6 +6,7 @@
'pmbus_driver_device_tests.cpp',
'rail_tests.cpp',
'standard_device_tests.cpp',
+ 'ucd90x_device_tests.cpp',
dependencies: [
gmock,
gtest,
diff --git a/phosphor-power-sequencer/test/pmbus_driver_device_tests.cpp b/phosphor-power-sequencer/test/pmbus_driver_device_tests.cpp
index 322499e..92f7916 100644
--- a/phosphor-power-sequencer/test/pmbus_driver_device_tests.cpp
+++ b/phosphor-power-sequencer/test/pmbus_driver_device_tests.cpp
@@ -802,6 +802,10 @@
createFile("in1_label"); // PAGE 6 -> file number 1
MockServices services;
+ std::vector<int> gpioValues{1, 1, 1};
+ EXPECT_CALL(services, getGPIOValues("xyz_pseq"))
+ .Times(1)
+ .WillOnce(Return(gpioValues));
std::string name{"xyz_pseq"};
std::vector<std::unique_ptr<Rail>> rails;
diff --git a/phosphor-power-sequencer/test/ucd90x_device_tests.cpp b/phosphor-power-sequencer/test/ucd90x_device_tests.cpp
new file mode 100644
index 0000000..2ec8b2e
--- /dev/null
+++ b/phosphor-power-sequencer/test/ucd90x_device_tests.cpp
@@ -0,0 +1,249 @@
+/**
+ * Copyright © 2024 IBM Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "mock_pmbus.hpp"
+#include "mock_services.hpp"
+#include "pmbus.hpp"
+#include "rail.hpp"
+#include "services.hpp"
+#include "ucd90x_device.hpp"
+
+#include <cstdint>
+#include <exception>
+#include <map>
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+using namespace phosphor::power::sequencer;
+using namespace phosphor::pmbus;
+
+using ::testing::Return;
+using ::testing::Throw;
+
+/**
+ * Creates a Rail object that checks for a pgood fault using a GPIO.
+ *
+ * @param name Unique name for the rail
+ * @param gpio GPIO line to read to determine the pgood status of the rail
+ * @return Rail object
+ */
+std::unique_ptr<Rail> createRail(const std::string& name, unsigned int gpioLine)
+{
+ std::optional<std::string> presence{};
+ std::optional<uint8_t> page{};
+ bool isPowerSupplyRail{false};
+ bool checkStatusVout{false};
+ bool compareVoltageToLimit{false};
+ bool activeLow{false};
+ std::optional<GPIO> gpio{GPIO{gpioLine, activeLow}};
+ return std::make_unique<Rail>(name, presence, page, isPowerSupplyRail,
+ checkStatusVout, compareVoltageToLimit, gpio);
+}
+
+TEST(UCD90xDeviceTests, Constructor)
+{
+ MockServices services;
+
+ std::string name{"ucd90320"};
+ std::vector<std::unique_ptr<Rail>> rails;
+ rails.emplace_back(createRail("VDD", 5));
+ rails.emplace_back(createRail("VIO", 7));
+ uint8_t bus{3};
+ uint16_t address{0x72};
+ UCD90xDevice device{name, std::move(rails), services, bus, address};
+
+ EXPECT_EQ(device.getName(), name);
+ EXPECT_EQ(device.getRails().size(), 2);
+ EXPECT_EQ(device.getRails()[0]->getName(), "VDD");
+ EXPECT_EQ(device.getRails()[1]->getName(), "VIO");
+ EXPECT_EQ(device.getBus(), bus);
+ EXPECT_EQ(device.getAddress(), address);
+ EXPECT_EQ(device.getDriverName(), "ucd9000");
+ EXPECT_EQ(device.getInstance(), 0);
+ EXPECT_NE(&(device.getPMBusInterface()), nullptr);
+}
+
+TEST(UCD90xDeviceTests, GetMfrStatus)
+{
+ // Test where works
+ {
+ MockServices services;
+
+ std::string name{"ucd90320"};
+ std::vector<std::unique_ptr<Rail>> rails;
+ uint8_t bus{3};
+ uint16_t address{0x72};
+ UCD90xDevice device{name, std::move(rails), services, bus, address};
+
+ MockPMBus& pmbus = static_cast<MockPMBus&>(device.getPMBusInterface());
+ uint64_t mfrStatus{0x123456789abcull};
+ EXPECT_CALL(pmbus, read("mfr_status", Type::HwmonDeviceDebug, true))
+ .Times(1)
+ .WillOnce(Return(mfrStatus));
+
+ EXPECT_EQ(device.getMfrStatus(), mfrStatus);
+ }
+
+ // Test where fails with exception
+ {
+ MockServices services;
+
+ std::string name{"ucd90320"};
+ std::vector<std::unique_ptr<Rail>> rails;
+ uint8_t bus{3};
+ uint16_t address{0x72};
+ UCD90xDevice device{name, std::move(rails), services, bus, address};
+
+ MockPMBus& pmbus = static_cast<MockPMBus&>(device.getPMBusInterface());
+ EXPECT_CALL(pmbus, read("mfr_status", Type::HwmonDeviceDebug, true))
+ .Times(1)
+ .WillOnce(Throw(std::runtime_error{"File does not exist"}));
+
+ try
+ {
+ device.getMfrStatus();
+ ADD_FAILURE() << "Should not have reached this line.";
+ }
+ catch (const std::exception& e)
+ {
+ EXPECT_STREQ(e.what(),
+ "Unable to read MFR_STATUS for device ucd90320: "
+ "File does not exist");
+ }
+ }
+}
+
+TEST(UCD90xDeviceTests, StorePgoodFaultDebugData)
+{
+ // This is a protected method and cannot be called directly from a gtest.
+ // Call findPgoodFault() which calls storePgoodFaultDebugData().
+
+ // Test where works
+ {
+ MockServices services;
+ std::vector<int> gpioValues{1, 1, 0};
+ EXPECT_CALL(services, getGPIOValues("ucd90320"))
+ .Times(1)
+ .WillOnce(Return(gpioValues));
+ EXPECT_CALL(services,
+ logInfoMsg("Device ucd90320 GPIO values: [1, 1, 0]"))
+ .Times(1);
+ EXPECT_CALL(services,
+ logInfoMsg("Device ucd90320 MFR_STATUS: 0x123456789abc"))
+ .Times(1);
+ EXPECT_CALL(
+ services,
+ logErrorMsg(
+ "Pgood fault found in rail monitored by device ucd90320"))
+ .Times(1);
+ EXPECT_CALL(services, logErrorMsg("Pgood fault detected in rail VDD"))
+ .Times(1);
+ EXPECT_CALL(
+ services,
+ logErrorMsg(
+ "Rail VDD pgood GPIO line offset 2 has inactive value 0"))
+ .Times(1);
+
+ std::string name{"ucd90320"};
+ std::vector<std::unique_ptr<Rail>> rails;
+ rails.emplace_back(createRail("VDD", 2));
+ uint8_t bus{3};
+ uint16_t address{0x72};
+ UCD90xDevice device{name, std::move(rails), services, bus, address};
+
+ MockPMBus& pmbus = static_cast<MockPMBus&>(device.getPMBusInterface());
+ EXPECT_CALL(pmbus, getPath(Type::Hwmon))
+ .Times(1)
+ .WillOnce(Return("/tmp"));
+ EXPECT_CALL(pmbus, read("mfr_status", Type::HwmonDeviceDebug, true))
+ .Times(1)
+ .WillOnce(Return(0x123456789abcull));
+
+ // Call findPgoodFault() which calls storePgoodFaultDebugData()
+ std::string powerSupplyError{};
+ std::map<std::string, std::string> additionalData{};
+ std::string error = device.findPgoodFault(services, powerSupplyError,
+ additionalData);
+ EXPECT_EQ(error,
+ "xyz.openbmc_project.Power.Error.PowerSequencerVoltageFault");
+ EXPECT_EQ(additionalData.size(), 6);
+ EXPECT_EQ(additionalData["MFR_STATUS"], "0x123456789abc");
+ EXPECT_EQ(additionalData["DEVICE_NAME"], "ucd90320");
+ EXPECT_EQ(additionalData["GPIO_VALUES"], "[1, 1, 0]");
+ EXPECT_EQ(additionalData["RAIL_NAME"], "VDD");
+ EXPECT_EQ(additionalData["GPIO_LINE"], "2");
+ EXPECT_EQ(additionalData["GPIO_VALUE"], "0");
+ }
+
+ // Test where exception thrown trying to get MFR_STATUS
+ {
+ MockServices services;
+ std::vector<int> gpioValues{1, 1, 0};
+ EXPECT_CALL(services, getGPIOValues("ucd90320"))
+ .Times(1)
+ .WillOnce(Return(gpioValues));
+ EXPECT_CALL(services,
+ logInfoMsg("Device ucd90320 GPIO values: [1, 1, 0]"))
+ .Times(1);
+ EXPECT_CALL(
+ services,
+ logErrorMsg(
+ "Pgood fault found in rail monitored by device ucd90320"))
+ .Times(1);
+ EXPECT_CALL(services, logErrorMsg("Pgood fault detected in rail VDD"))
+ .Times(1);
+ EXPECT_CALL(
+ services,
+ logErrorMsg(
+ "Rail VDD pgood GPIO line offset 2 has inactive value 0"))
+ .Times(1);
+
+ std::string name{"ucd90320"};
+ std::vector<std::unique_ptr<Rail>> rails;
+ rails.emplace_back(createRail("VDD", 2));
+ uint8_t bus{3};
+ uint16_t address{0x72};
+ UCD90xDevice device{name, std::move(rails), services, bus, address};
+
+ MockPMBus& pmbus = static_cast<MockPMBus&>(device.getPMBusInterface());
+ EXPECT_CALL(pmbus, getPath(Type::Hwmon))
+ .Times(1)
+ .WillOnce(Return("/tmp"));
+ EXPECT_CALL(pmbus, read("mfr_status", Type::HwmonDeviceDebug, true))
+ .Times(1)
+ .WillOnce(Throw(std::runtime_error{"File does not exist"}));
+
+ // Call findPgoodFault() which calls storePgoodFaultDebugData()
+ std::string powerSupplyError{};
+ std::map<std::string, std::string> additionalData{};
+ std::string error = device.findPgoodFault(services, powerSupplyError,
+ additionalData);
+ EXPECT_EQ(error,
+ "xyz.openbmc_project.Power.Error.PowerSequencerVoltageFault");
+ EXPECT_EQ(additionalData.size(), 5);
+ EXPECT_EQ(additionalData["DEVICE_NAME"], "ucd90320");
+ EXPECT_EQ(additionalData["GPIO_VALUES"], "[1, 1, 0]");
+ EXPECT_EQ(additionalData["RAIL_NAME"], "VDD");
+ EXPECT_EQ(additionalData["GPIO_LINE"], "2");
+ EXPECT_EQ(additionalData["GPIO_VALUE"], "0");
+ }
+}