phosphor-power-sequencer/src/ucd90x_monitor.cpp

/**
 * Copyright © 2022 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 "ucd90x_monitor.hpp"

#include "types.hpp"
#include "utility.hpp"

#include <fmt/format.h>
#include <fmt/ranges.h>

#include <gpiod.hpp>
#include <nlohmann/json.hpp>
#include <phosphor-logging/log.hpp>

#include <algorithm>
#include <chrono>
#include <exception>
#include <fstream>

namespace phosphor::power::sequencer
{

using json = nlohmann::json;
using namespace pmbus;
using namespace phosphor::logging;

const std::string compatibleInterface =
    "xyz.openbmc_project.Configuration.IBMCompatibleSystem";
const std::string compatibleNamesProperty = "Names";

UCD90xMonitor::UCD90xMonitor(sdbusplus::bus_t& bus, std::uint8_t i2cBus,
                             std::uint16_t i2cAddress,
                             const std::string& deviceName,
                             size_t numberPages) :
    PowerSequencerMonitor(bus),
    deviceName{deviceName},
    match{bus,
          sdbusplus::bus::match::rules::interfacesAdded() +
              sdbusplus::bus::match::rules::sender(
                  "xyz.openbmc_project.EntityManager"),
          std::bind(&UCD90xMonitor::interfacesAddedHandler, this,
                    std::placeholders::_1)},
    numberPages{numberPages},
    pmbusInterface{
        fmt::format("/sys/bus/i2c/devices/{}-{:04x}", i2cBus, i2cAddress)
            .c_str(),
        "ucd9000", 0}
{
    log<level::DEBUG>(
        fmt::format("Device path: {}", pmbusInterface.path().string()).c_str());
    log<level::DEBUG>(fmt::format("Hwmon path: {}",
                                  pmbusInterface.getPath(Type::Hwmon).string())
                          .c_str());
    log<level::DEBUG>(fmt::format("Debug path: {}",
                                  pmbusInterface.getPath(Type::Debug).string())
                          .c_str());
    log<level::DEBUG>(
        fmt::format("Device debug path: {}",
                    pmbusInterface.getPath(Type::DeviceDebug).string())
            .c_str());
    log<level::DEBUG>(
        fmt::format("Hwmon device debug path: {}",
                    pmbusInterface.getPath(Type::HwmonDeviceDebug).string())
            .c_str());

    // Use the compatible system types information, if already available, to
    // load the configuration file
    findCompatibleSystemTypes();
}

void UCD90xMonitor::findCompatibleSystemTypes()
{
    try
    {
        auto subTree = util::getSubTree(bus, "/xyz/openbmc_project/inventory",
                                        compatibleInterface, 0);

        auto objectIt = subTree.cbegin();
        if (objectIt != subTree.cend())
        {
            const auto& objPath = objectIt->first;

            // Get the first service name
            auto serviceIt = objectIt->second.cbegin();
            if (serviceIt != objectIt->second.cend())
            {
                std::string service = serviceIt->first;
                if (!service.empty())
                {
                    std::vector<std::string> compatibleSystemTypes;

                    // Get compatible system types property value
                    util::getProperty(compatibleInterface,
                                      compatibleNamesProperty, objPath, service,
                                      bus, compatibleSystemTypes);

                    log<level::DEBUG>(
                        fmt::format("Found compatible systems: {}",
                                    compatibleSystemTypes)
                            .c_str());
                    // Use compatible systems information to find config file
                    findConfigFile(compatibleSystemTypes);
                }
            }
        }
    }
    catch (const std::exception&)
    {
        // Compatible system types information is not available.
    }
}

void UCD90xMonitor::findConfigFile(
    const std::vector<std::string>& compatibleSystemTypes)
{
    // Expected config file path name:
    // /usr/share/phosphor-power-sequencer/<deviceName>Monitor_<systemType>.json

    // Add possible file names based on compatible system types (if any)
    for (const std::string& systemType : compatibleSystemTypes)
    {
        // Check if file exists
        std::filesystem::path pathName{"/usr/share/phosphor-power-sequencer/" +
                                       deviceName + "Monitor_" + systemType +
                                       ".json"};
        log<level::DEBUG>(
            fmt::format("Attempting config file path: {}", pathName.string())
                .c_str());
        if (std::filesystem::exists(pathName))
        {
            log<level::INFO>(
                fmt::format("Config file path: {}", pathName.string()).c_str());
            parseConfigFile(pathName);
            break;
        }
    }
}

void UCD90xMonitor::interfacesAddedHandler(sdbusplus::message_t& msg)
{
    // Only continue if message is valid and rails / pins have not already been
    // found
    if (!msg || !rails.empty())
    {
        return;
    }

    try
    {
        // Read the dbus message
        sdbusplus::message::object_path objPath;
        std::map<std::string,
                 std::map<std::string, std::variant<std::vector<std::string>>>>
            interfaces;
        msg.read(objPath, interfaces);

        // Find the compatible interface, if present
        auto itIntf = interfaces.find(compatibleInterface);
        if (itIntf != interfaces.cend())
        {
            // Find the Names property of the compatible interface, if present
            auto itProp = itIntf->second.find(compatibleNamesProperty);
            if (itProp != itIntf->second.cend())
            {
                // Get value of Names property
                const auto& propValue = std::get<0>(itProp->second);
                if (!propValue.empty())
                {
                    log<level::INFO>(
                        fmt::format(
                            "InterfacesAdded for compatible systems: {}",
                            propValue)
                            .c_str());

                    // Use compatible systems information to find config file
                    findConfigFile(propValue);
                }
            }
        }
    }
    catch (const std::exception&)
    {
        // Error trying to read interfacesAdded message.
    }
}

bool UCD90xMonitor::isPresent(const std::string& inventoryPath)
{
    // Empty path indicates no presence check is needed
    if (inventoryPath.empty())
    {
        return true;
    }

    // Get presence from D-Bus interface/property
    try
    {
        bool present{true};
        util::getProperty(INVENTORY_IFACE, PRESENT_PROP, inventoryPath,
                          INVENTORY_MGR_IFACE, bus, present);
        log<level::INFO>(
            fmt::format("Presence, path: {}, value: {}", inventoryPath, present)
                .c_str());
        return present;
    }
    catch (const std::exception& e)
    {
        log<level::INFO>(
            fmt::format("Error getting presence property, path: {}, error: {}",
                        inventoryPath, e.what())
                .c_str());
        return false;
    }
}

void UCD90xMonitor::formatGpioValues(
    const std::vector<int>& values, unsigned int /*numberLines*/,
    std::map<std::string, std::string>& additionalData) const
{
    log<level::INFO>(fmt::format("GPIO values: {}", values).c_str());
    additionalData.emplace("GPIO_VALUES", fmt::format("{}", values));
}

void UCD90xMonitor::onFailure(bool timeout, const std::string& powerSupplyError)
{
    std::string message;
    std::map<std::string, std::string> additionalData{};

    try
    {
        onFailureCheckRails(message, additionalData, powerSupplyError);
        log<level::DEBUG>(
            fmt::format("After onFailureCheckRails, message: {}", message)
                .c_str());
        onFailureCheckPins(message, additionalData);
        log<level::DEBUG>(
            fmt::format("After onFailureCheckPins, message: {}", message)
                .c_str());
    }
    catch (const std::exception& e)
    {
        log<level::ERR>(
            fmt::format("Error when collecting metadata, error: {}", e.what())
                .c_str());
        additionalData.emplace("ERROR", e.what());
    }

    if (message.empty())
    {
        // Could not isolate, but we know something failed, so issue a timeout
        // or generic power good error
        message = timeout ? powerOnTimeoutError : shutdownError;
    }
    logError(message, additionalData);
    if (!timeout)
    {
        createBmcDump();
    }
}

void UCD90xMonitor::onFailureCheckPins(
    std::string& message, std::map<std::string, std::string>& additionalData)
{
    // Create a lower case version of device name to use as label in libgpiod
    std::string label{deviceName};
    std::transform(label.begin(), label.end(), label.begin(), ::tolower);

    // Setup a list of all the GPIOs on the chip
    gpiod::chip chip{label, gpiod::chip::OPEN_BY_LABEL};
    log<level::INFO>(fmt::format("GPIO chip name: {}", chip.name()).c_str());
    log<level::INFO>(fmt::format("GPIO chip label: {}", chip.label()).c_str());
    unsigned int numberLines = chip.num_lines();
    log<level::INFO>(
        fmt::format("GPIO chip number of lines: {}", numberLines).c_str());

    // Workaround libgpiod bulk line maximum by getting values from individual
    // lines
    std::vector<int> values;
    try
    {
        for (unsigned int offset = 0; offset < numberLines; ++offset)
        {
            gpiod::line line = chip.get_line(offset);
            line.request({"phosphor-power-control",
                          gpiod::line_request::DIRECTION_INPUT, 0});
            values.push_back(line.get_value());
            line.release();
        }
    }
    catch (const std::exception& e)
    {
        log<level::ERR>(
            fmt::format("Error reading device GPIOs, error: {}", e.what())
                .c_str());
        additionalData.emplace("GPIO_ERROR", e.what());
    }

    formatGpioValues(values, numberLines, additionalData);

    // Only check GPIOs if no rail fail was found
    if (message.empty())
    {
        for (size_t pin = 0; pin < pins.size(); ++pin)
        {
            unsigned int line = pins[pin].line;
            if (line < values.size())
            {
                int value = values[line];

                if ((value == 0) && isPresent(pins[pin].presence))
                {
                    additionalData.emplace("INPUT_NUM",
                                           fmt::format("{}", line));
                    additionalData.emplace("INPUT_NAME", pins[pin].name);
                    message =
                        "xyz.openbmc_project.Power.Error.PowerSequencerPGOODFault";
                    return;
                }
            }
        }
    }
}

void UCD90xMonitor::onFailureCheckRails(
    std::string& message, std::map<std::string, std::string>& additionalData,
    const std::string& powerSupplyError)
{
    auto statusWord = readStatusWord();
    additionalData.emplace("STATUS_WORD", fmt::format("{:#06x}", statusWord));
    try
    {
        additionalData.emplace("MFR_STATUS",
                               fmt::format("{:#014x}", readMFRStatus()));
    }
    catch (const std::exception& e)
    {
        log<level::ERR>(
            fmt::format("Error when collecting MFR_STATUS, error: {}", e.what())
                .c_str());
        additionalData.emplace("ERROR", e.what());
    }

    // The status_word register has a summary bit to tell us if each page even
    // needs to be checked
    if (statusWord & status_word::VOUT_FAULT)
    {
        for (size_t page = 0; page < numberPages; page++)
        {
            auto statusVout = pmbusInterface.insertPageNum(STATUS_VOUT, page);
            if (pmbusInterface.exists(statusVout, Type::Debug))
            {
                uint8_t vout = pmbusInterface.read(statusVout, Type::Debug);

                if (vout)
                {
                    // If any bits are on log them, though some are just
                    // warnings so they won't cause errors
                    log<level::INFO>(
                        fmt::format("{}, value: {:#04x}", statusVout, vout)
                            .c_str());

                    // Log errors if any non-warning bits on
                    if (vout & ~status_vout::WARNING_MASK)
                    {
                        additionalData.emplace(
                            fmt::format("STATUS{}_VOUT", page),
                            fmt::format("{:#04x}", vout));

                        // Base the callouts on the first present vout failure
                        // found
                        if (message.empty() && (page < rails.size()) &&
                            isPresent(rails[page].presence))
                        {
                            additionalData.emplace("RAIL_NAME",
                                                   rails[page].name);

                            // Use power supply error if set and 12v rail has
                            // failed, else use voltage error
                            message =
                                ((page == 0) && !powerSupplyError.empty())
                                    ? powerSupplyError
                                    : "xyz.openbmc_project.Power.Error.PowerSequencerVoltageFault";
                        }
                    }
                }
            }
        }
    }
    // If no vout failure found, but power supply error is set, use power supply
    // error
    if (message.empty())
    {
        message = powerSupplyError;
    }
}

void UCD90xMonitor::parseConfigFile(const std::filesystem::path& pathName)
{
    try
    {
        log<level::DEBUG>(
            std::string("Loading configuration file " + pathName.string())
                .c_str());

        std::ifstream file{pathName};
        json rootElement = json::parse(file);
        log<level::DEBUG>(fmt::format("Parsed, root element is_object: {}",
                                      rootElement.is_object())
                              .c_str());

        // Parse rail information from config file
        auto railsIterator = rootElement.find("rails");
        if (railsIterator != rootElement.end())
        {
            for (const auto& railElement : *railsIterator)
            {
                log<level::DEBUG>(fmt::format("Rail element is_object: {}",
                                              railElement.is_object())
                                      .c_str());

                auto nameIterator = railElement.find("name");
                if (nameIterator != railElement.end())
                {
                    log<level::DEBUG>(fmt::format("Name element is_string: {}",
                                                  (*nameIterator).is_string())
                                          .c_str());
                    Rail rail;
                    rail.name = (*nameIterator).get<std::string>();

                    // Presence element is optional
                    auto presenceIterator = railElement.find("presence");
                    if (presenceIterator != railElement.end())
                    {
                        log<level::DEBUG>(
                            fmt::format("Presence element is_string: {}",
                                        (*presenceIterator).is_string())
                                .c_str());

                        rail.presence = (*presenceIterator).get<std::string>();
                    }

                    log<level::DEBUG>(
                        fmt::format("Adding rail, name: {}, presence: {}",
                                    rail.name, rail.presence)
                            .c_str());
                    rails.emplace_back(std::move(rail));
                }
                else
                {
                    log<level::ERR>(
                        fmt::format(
                            "No name found within rail in configuration file: {}",
                            pathName.string())
                            .c_str());
                }
            }
        }
        else
        {
            log<level::ERR>(
                fmt::format("No rails found in configuration file: {}",
                            pathName.string())
                    .c_str());
        }
        log<level::DEBUG>(
            fmt::format("Found number of rails: {}", rails.size()).c_str());

        // Parse pin information from config file
        auto pinsIterator = rootElement.find("pins");
        if (pinsIterator != rootElement.end())
        {
            for (const auto& pinElement : *pinsIterator)
            {
                log<level::DEBUG>(fmt::format("Pin element is_object: {}",
                                              pinElement.is_object())
                                      .c_str());
                auto nameIterator = pinElement.find("name");
                auto lineIterator = pinElement.find("line");
                if (nameIterator != pinElement.end() &&
                    lineIterator != pinElement.end())
                {
                    log<level::DEBUG>(fmt::format("Name element is_string: {}",
                                                  (*nameIterator).is_string())
                                          .c_str());
                    log<level::DEBUG>(
                        fmt::format("Line element is_number_integer: {}",
                                    (*lineIterator).is_number_integer())
                            .c_str());
                    Pin pin;
                    pin.name = (*nameIterator).get<std::string>();
                    pin.line = (*lineIterator).get<unsigned int>();

                    // Presence element is optional
                    auto presenceIterator = pinElement.find("presence");
                    if (presenceIterator != pinElement.end())
                    {
                        log<level::DEBUG>(
                            fmt::format("Presence element is_string: {}",
                                        (*presenceIterator).is_string())
                                .c_str());
                        pin.presence = (*presenceIterator).get<std::string>();
                    }

                    log<level::DEBUG>(
                        fmt::format(
                            "Adding pin, name: {}, line: {}, presence: {}",
                            pin.name, pin.line, pin.presence)
                            .c_str());
                    pins.emplace_back(std::move(pin));
                }
                else
                {
                    log<level::ERR>(
                        fmt::format(
                            "No name or line found within pin in configuration file: {}",
                            pathName.string())
                            .c_str());
                }
            }
        }
        else
        {
            log<level::ERR>(
                fmt::format("No pins found in configuration file: {}",
                            pathName.string())
                    .c_str());
        }
        log<level::DEBUG>(
            fmt::format("Found number of pins: {}", pins.size()).c_str());
    }
    catch (const std::exception& e)
    {
        log<level::ERR>(
            fmt::format("Error parsing configuration file, error: {}", e.what())
                .c_str());
    }
}

uint16_t UCD90xMonitor::readStatusWord()
{
    return pmbusInterface.read(STATUS_WORD, Type::Debug);
}

uint64_t UCD90xMonitor::readMFRStatus()
{
    const std::string mfrStatus = "mfr_status";
    return pmbusInterface.read(mfrStatus, Type::HwmonDeviceDebug);
}

} // namespace phosphor::power::sequencer