power-sequencer/ucd90160.hpp

#pragma once

#include <algorithm>
#include <experimental/filesystem>
#include <map>
#include <vector>
#include "device.hpp"
#include "gpio.hpp"
#include "pmbus.hpp"
#include "types.hpp"

namespace witherspoon
{
namespace power
{

//Error type, callout
using PartCallout =
        std::tuple<ucd90160::extraAnalysisType, std::string>;

/**
 * @class UCD90160
 *
 * This class implements fault analysis for the UCD90160
 * power sequencer device.
 *
 */
class UCD90160 : public Device
{
    public:

        UCD90160() = delete;
        ~UCD90160() = default;
        UCD90160(const UCD90160&) = delete;
        UCD90160& operator=(const UCD90160&) = delete;
        UCD90160(UCD90160&&) = default;
        UCD90160& operator=(UCD90160&&) = default;

        /**
         * Constructor
         *
         * @param[in] instance - the device instance number
         */
        UCD90160(size_t instance);

        /**
         * Analyzes the device for errors when the device is
         * known to be in an error state.  A log will be created.
         */
        void onFailure() override;

        /**
         * Checks the device for errors and only creates a log
         * if one is found.
         */
        void analyze() override;

        /**
         * Clears faults in the device
         */
        void clearFaults() override
        {
        }

    private:

        /**
         * Reports an error for a GPU PGOOD failure
         *
         * @param[in] callout - the GPU callout string
         */
        void gpuPGOODError(const std::string& callout);

        /**
         * Reports an error for a GPU OverTemp failure
         *
         * @param[in] callout - the GPU callout string
         */
        void gpuOverTempError(const std::string& callout);

        /**
         * Given the device path for a chip, find its gpiochip
         * path
         *
         * @param[in] path - device path, like
         *                   /sys/devices/.../i2c-11/11-0064
         *
         * @return fs::path - The gpiochip path, like
         *                   /dev/gpiochip1
         */
        static std::experimental::filesystem::path findGPIODevice(
                const std::experimental::filesystem::path& path);

        /**
         * Checks for VOUT faults on the device.
         *
         * This device can monitor voltages of its dependent
         * devices, and VOUT faults are voltage faults
         * on these devices.
         *
         * @return bool - true if an error log was created
         */
        bool checkVOUTFaults();

        /**
         * Checks for PGOOD faults on the device.
         *
         * This device can monitor the PGOOD signals of its dependent
         * devices, and this check will look for faults of
         * those PGOODs.
         *
         * @param[in] polling - If this is running while polling for errors,
         *                      as opposing to analyzing a fail condition.
         *
         * @return bool - true if an error log was created
         */
         bool checkPGOODFaults(bool polling);

        /**
         * Creates an error log when the device has an error
         * but it isn't a PGOOD or voltage failure.
         */
        void createPowerFaultLog();

        /**
         * Reads the status_word register
         *
         * @return uint16_t - the register contents
         */
        uint16_t readStatusWord();

        /**
         * Reads the mfr_status register
         *
         * @return uint32_t - the register contents
         */
        uint32_t readMFRStatus();

        /**
         * Does any additional fault analysis based on the
         * value of the extraAnalysisType field in the GPIOConfig
         * entry.
         *
         * Used to get better callouts.
         *
         * @param[in] config - the GPIOConfig entry to use
         *
         * @return bool - true if a HW error was found, false else
         */
        bool doExtraAnalysis(const ucd90160::GPIConfig& config);

        /**
         * Does additional fault analysis using GPIOs to
         * specifically identify the failing part.
         *
         * Used when there are too many PGOOD inputs for
         * the UCD90160 to handle, so just a summary bit
         * is wired into the chip, and then the specific
         * fault GPIOs are off of a different GPIO device,
         * like an IO expander.
         *
         * @param[in] type - the type of analysis to do
         *
         * @return bool - true if a HW error was found, false else
         */
        bool doGPIOAnalysis(ucd90160::extraAnalysisType type);

        /**
         * Says if we've already logged a Vout fault
         *
         * The policy is only 1 of the same error will
         * be logged for the duration of a class instance.
         *
         * @param[in] page - the page to check
         *
         * @return bool - if we've already logged a fault against
         *                this page
         */
        inline bool isVoutFaultLogged(uint32_t page) const
        {
            return std::find(voutErrors.begin(),
                             voutErrors.end(),
                             page) != voutErrors.end();
        }

        /**
         * Saves that a Vout fault has been logged
         *
         * @param[in] page - the page the error was logged against
         */
        inline void setVoutFaultLogged(uint32_t page)
        {
            voutErrors.push_back(page);
        }

        /**
         * Says if we've already logged a PGOOD fault
         *
         * The policy is only 1 of the same errors will
         * be logged for the duration of a class instance.
         *
         * @param[in] input - the input to check
         *
         * @return bool - if we've already logged a fault against
         *                this input
         */
        inline bool isPGOODFaultLogged(uint32_t input) const
        {
            return std::find(pgoodErrors.begin(),
                             pgoodErrors.end(),
                             input) != pgoodErrors.end();
        }

        /**
         * Says if we've already logged a specific fault
         * against a specific part
         *
         * @param[in] callout - error type and name tuple
         *
         * @return bool - if we've already logged this fault
         *                against this part
         */
        inline bool isPartCalledOut(const PartCallout& callout) const
        {
            return std::find(callouts.begin(),
                             callouts.end(),
                             callout) != callouts.end();
        }

        /**
         * Saves that a PGOOD fault has been logged
         *
         * @param[in] input - the input the error was logged against
         */
        inline void setPGOODFaultLogged(uint32_t input)
        {
            pgoodErrors.push_back(input);
        }

        /**
         * Saves that a specific fault on a specific part has been done
         *
         * @param[in] callout - error type and name tuple
         */
        inline void setPartCallout(const PartCallout& callout)
        {
            callouts.push_back(callout);
        }

        /**
         * List of pages that Vout errors have
         * already been logged against
         */
        std::vector<uint32_t> voutErrors;

        /**
         * List of inputs that PGOOD errors have
         * already been logged against
         */
        std::vector<uint32_t> pgoodErrors;

        /**
         * List of callouts that already been done
         */
        std::vector<PartCallout> callouts;

        /**
         * The read/write interface to this hardware
         */
        pmbus::PMBus interface;

        /**
         * A map of GPI pin IDs to the GPIO object
         * used to access them
         */
        std::map<size_t, std::unique_ptr<gpio::GPIO>> gpios;

        /**
         * Keeps track of device access errors to avoid repeatedly
         * logging errors for bad hardware
         */
        bool accessError = false;

        /**
         * Keeps track of GPIO access errors when doing the in depth
         * PGOOD fault analysis to avoid repeatedly logging errors
         * for bad hardware
         */
        bool gpioAccessError = false;

        /**
         * The path to the GPIO device used to read
         * the GPI (PGOOD) status
         */
        std::experimental::filesystem::path gpioDevice;

        /**
         * Map of device instance to the instance specific data
         */
        static const ucd90160::DeviceMap deviceMap;
};

}
}