phosphor-power-sequencer/src/pmbus_driver_device.cpp - openbmc/phosphor-power - Gitiles

 /**
  * 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 "pmbus_driver_device.hpp"

 #include <ctype.h> // for tolower()

 #include <algorithm>
 #include <exception>
 #include <filesystem>
 #include <format>
 #include <regex>
 #include <stdexcept>

 namespace phosphor::power::sequencer
 {

 using namespace pmbus;
 namespace fs = std::filesystem;

 std::vector<int> PMBusDriverDevice::getGPIOValues(Services& services)
 {
     // Get lower case version of device name to use as chip label
     std::string label{name};
     std::transform(label.begin(), label.end(), label.begin(), ::tolower);

     // Read the GPIO values by specifying the chip label
     std::vector<int> values;
     try
     {
         values = services.getGPIOValues(label);
     }
     catch (const std::exception& e)
     {
         throw std::runtime_error{std::format(
             "Unable to read GPIO values from device {} using label {}: {}",
             name, label, e.what())};
     }
     return values;
 }

 uint16_t PMBusDriverDevice::getStatusWord(uint8_t page)
 {
     uint16_t value{0};
     try
     {
         std::string fileName = std::format("status{:d}", page);
         value = pmbusInterface->read(fileName, Type::Debug);
     }
     catch (const std::exception& e)
     {
         throw std::runtime_error{std::format(
             "Unable to read STATUS_WORD for PAGE {:d} of device {}: {}", page,
             name, e.what())};
     }
     return value;
 }

 uint8_t PMBusDriverDevice::getStatusVout(uint8_t page)
 {
     uint8_t value{0};
     try
     {
         std::string fileName = std::format("status{:d}_vout", page);
         value = pmbusInterface->read(fileName, Type::Debug);
     }
     catch (const std::exception& e)
     {
         throw std::runtime_error{std::format(
             "Unable to read STATUS_VOUT for PAGE {:d} of device {}: {}", page,
             name, e.what())};
     }
     return value;
 }

 double PMBusDriverDevice::getReadVout(uint8_t page)
 {
     double volts{0.0};
     try
     {
         unsigned int fileNumber = getFileNumber(page);
         std::string fileName = std::format("in{}_input", fileNumber);
         std::string millivoltsStr = pmbusInterface->readString(fileName,
                                                                Type::Hwmon);
         unsigned long millivolts = std::stoul(millivoltsStr);
         volts = millivolts / 1000.0;
     }
     catch (const std::exception& e)
     {
         throw std::runtime_error{std::format(
             "Unable to read READ_VOUT for PAGE {:d} of device {}: {}", page,
             name, e.what())};
     }
     return volts;
 }

 double PMBusDriverDevice::getVoutUVFaultLimit(uint8_t page)
 {
     double volts{0.0};
     try
     {
         unsigned int fileNumber = getFileNumber(page);
         std::string fileName = std::format("in{}_lcrit", fileNumber);
         std::string millivoltsStr = pmbusInterface->readString(fileName,
                                                                Type::Hwmon);
         unsigned long millivolts = std::stoul(millivoltsStr);
         volts = millivolts / 1000.0;
     }
     catch (const std::exception& e)
     {
         throw std::runtime_error{std::format(
             "Unable to read VOUT_UV_FAULT_LIMIT for PAGE {:d} of device {}: {}",
             page, name, e.what())};
     }
     return volts;
 }

 unsigned int PMBusDriverDevice::getFileNumber(uint8_t page)
 {
     if (pageToFileNumber.empty())
     {
         buildPageToFileNumberMap();
     }

     auto it = pageToFileNumber.find(page);
     if (it == pageToFileNumber.end())
     {
         throw std::runtime_error{std::format(
             "Unable to find hwmon file number for PAGE {:d} of device {}", page,
             name)};
     }

     return it->second;
 }

 void PMBusDriverDevice::buildPageToFileNumberMap()
 {
     // Clear any existing mappings
     pageToFileNumber.clear();

     // Build mappings using voltage label files in hwmon directory
     try
     {
         fs::path hwmonDir = pmbusInterface->getPath(Type::Hwmon);
         if (fs::is_directory(hwmonDir))
         {
             // Loop through all files in hwmon directory
             std::string fileName;
             unsigned int fileNumber;
             std::optional<uint8_t> page;
             for (const auto& f : fs::directory_iterator{hwmonDir})
             {
                 // If this is a voltage label file
                 fileName = f.path().filename().string();
                 if (isLabelFile(fileName, fileNumber))
                 {
                     // Read PMBus PAGE number from label file contents
                     page = readPageFromLabelFile(fileName);
                     if (page)
                     {
                         // Add mapping from PAGE number to file number
                         pageToFileNumber.emplace(*page, fileNumber);
                     }
                 }
             }
         }
     }
     catch (const std::exception& e)
     {
         throw std::runtime_error{
             std::format("Unable to map PMBus PAGE numbers to hwmon file "
                         "numbers for device {}: {}",
                         name, e.what())};
     }
 }

 bool PMBusDriverDevice::isLabelFile(const std::string& fileName,
                                     unsigned int& fileNumber)
 {
     bool isLabel{false};
     try
     {
         // Check if file name has expected pattern for voltage label file
         std::regex regex{"in(\\d+)_label"};
         std::smatch results;
         if (std::regex_match(fileName, results, regex))
         {
             // Verify 2 match results: entire match and one sub-match
             if (results.size() == 2)
             {
                 // Get sub-match that contains the file number
                 std::string fileNumberStr = results.str(1);
                 fileNumber = std::stoul(fileNumberStr);
                 isLabel = true;
             }
         }
     }
     catch (...)
     {
         // Ignore error.  If this file is needed for pgood fault detection, an
         // error will occur later when the necessary mapping is missing.  Avoid
         // logging unnecessary errors for files that may not be required.
     }
     return isLabel;
 }

 std::optional<uint8_t>
     PMBusDriverDevice::readPageFromLabelFile(const std::string& fileName)
 {
     std::optional<uint8_t> page;
     try
     {
         // Read voltage label file contents
         std::string contents = pmbusInterface->readString(fileName,
                                                           Type::Hwmon);

         // Check if file contents match the expected pattern
         std::regex regex{"vout(\\d+)"};
         std::smatch results;
         if (std::regex_match(contents, results, regex))
         {
             // Verify 2 match results: entire match and one sub-match
             if (results.size() == 2)
             {
                 // Get sub-match that contains the page number + 1
                 std::string pageStr = results.str(1);
                 page = std::stoul(pageStr) - 1;
             }
         }
     }
     catch (...)
     {
         // Ignore error.  If this file is needed for pgood fault detection, an
         // error will occur later when the necessary mapping is missing.  Avoid
         // logging unnecessary errors for files that may not be required.
     }
     return page;
 }

 } // namespace phosphor::power::sequencer
	/**
	* 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 "pmbus_driver_device.hpp"

	#include <ctype.h> // for tolower()

	#include <algorithm>
	#include <exception>
	#include <filesystem>
	#include <format>
	#include <regex>
	#include <stdexcept>

	namespace phosphor::power::sequencer
	{

	using namespace pmbus;
	namespace fs = std::filesystem;

	std::vector<int> PMBusDriverDevice::getGPIOValues(Services& services)
	{
	// Get lower case version of device name to use as chip label
	std::string label{name};
	std::transform(label.begin(), label.end(), label.begin(), ::tolower);

	// Read the GPIO values by specifying the chip label
	std::vector<int> values;
	try
	{
	values = services.getGPIOValues(label);
	}
	catch (const std::exception& e)
	{
	throw std::runtime_error{std::format(
	"Unable to read GPIO values from device {} using label {}: {}",
	name, label, e.what())};
	}
	return values;
	}

	uint16_t PMBusDriverDevice::getStatusWord(uint8_t page)
	{
	uint16_t value{0};
	try
	{
	std::string fileName = std::format("status{:d}", page);
	value = pmbusInterface->read(fileName, Type::Debug);
	}
	catch (const std::exception& e)
	{
	throw std::runtime_error{std::format(
	"Unable to read STATUS_WORD for PAGE {:d} of device {}: {}", page,
	name, e.what())};
	}
	return value;
	}

	uint8_t PMBusDriverDevice::getStatusVout(uint8_t page)
	{
	uint8_t value{0};
	try
	{
	std::string fileName = std::format("status{:d}_vout", page);
	value = pmbusInterface->read(fileName, Type::Debug);
	}
	catch (const std::exception& e)
	{
	throw std::runtime_error{std::format(
	"Unable to read STATUS_VOUT for PAGE {:d} of device {}: {}", page,
	name, e.what())};
	}
	return value;
	}

	double PMBusDriverDevice::getReadVout(uint8_t page)
	{
	double volts{0.0};
	try
	{
	unsigned int fileNumber = getFileNumber(page);
	std::string fileName = std::format("in{}_input", fileNumber);
	std::string millivoltsStr = pmbusInterface->readString(fileName,
	Type::Hwmon);
	unsigned long millivolts = std::stoul(millivoltsStr);
	volts = millivolts / 1000.0;
	}
	catch (const std::exception& e)
	{
	throw std::runtime_error{std::format(
	"Unable to read READ_VOUT for PAGE {:d} of device {}: {}", page,
	name, e.what())};
	}
	return volts;
	}

	double PMBusDriverDevice::getVoutUVFaultLimit(uint8_t page)
	{
	double volts{0.0};
	try
	{
	unsigned int fileNumber = getFileNumber(page);
	std::string fileName = std::format("in{}_lcrit", fileNumber);
	std::string millivoltsStr = pmbusInterface->readString(fileName,
	Type::Hwmon);
	unsigned long millivolts = std::stoul(millivoltsStr);
	volts = millivolts / 1000.0;
	}
	catch (const std::exception& e)
	{
	throw std::runtime_error{std::format(
	"Unable to read VOUT_UV_FAULT_LIMIT for PAGE {:d} of device {}: {}",
	page, name, e.what())};
	}
	return volts;
	}

	unsigned int PMBusDriverDevice::getFileNumber(uint8_t page)
	{
	if (pageToFileNumber.empty())
	{
	buildPageToFileNumberMap();
	}

	auto it = pageToFileNumber.find(page);
	if (it == pageToFileNumber.end())
	{
	throw std::runtime_error{std::format(
	"Unable to find hwmon file number for PAGE {:d} of device {}", page,
	name)};
	}

	return it->second;
	}

	void PMBusDriverDevice::buildPageToFileNumberMap()
	{
	// Clear any existing mappings
	pageToFileNumber.clear();

	// Build mappings using voltage label files in hwmon directory
	try
	{
	fs::path hwmonDir = pmbusInterface->getPath(Type::Hwmon);
	if (fs::is_directory(hwmonDir))
	{
	// Loop through all files in hwmon directory
	std::string fileName;
	unsigned int fileNumber;
	std::optional<uint8_t> page;
	for (const auto& f : fs::directory_iterator{hwmonDir})
	{
	// If this is a voltage label file
	fileName = f.path().filename().string();
	if (isLabelFile(fileName, fileNumber))
	{
	// Read PMBus PAGE number from label file contents
	page = readPageFromLabelFile(fileName);
	if (page)
	{
	// Add mapping from PAGE number to file number
	pageToFileNumber.emplace(*page, fileNumber);
	}
	}
	}
	}
	}
	catch (const std::exception& e)
	{
	throw std::runtime_error{
	std::format("Unable to map PMBus PAGE numbers to hwmon file "
	"numbers for device {}: {}",
	name, e.what())};
	}
	}

	bool PMBusDriverDevice::isLabelFile(const std::string& fileName,
	unsigned int& fileNumber)
	{
	bool isLabel{false};
	try
	{
	// Check if file name has expected pattern for voltage label file
	std::regex regex{"in(\\d+)_label"};
	std::smatch results;
	if (std::regex_match(fileName, results, regex))
	{
	// Verify 2 match results: entire match and one sub-match
	if (results.size() == 2)
	{
	// Get sub-match that contains the file number
	std::string fileNumberStr = results.str(1);
	fileNumber = std::stoul(fileNumberStr);
	isLabel = true;
	}
	}
	}
	catch (...)
	{
	// Ignore error. If this file is needed for pgood fault detection, an
	// error will occur later when the necessary mapping is missing. Avoid
	// logging unnecessary errors for files that may not be required.
	}
	return isLabel;
	}

	std::optional<uint8_t>
	PMBusDriverDevice::readPageFromLabelFile(const std::string& fileName)
	{
	std::optional<uint8_t> page;
	try
	{
	// Read voltage label file contents
	std::string contents = pmbusInterface->readString(fileName,
	Type::Hwmon);

	// Check if file contents match the expected pattern
	std::regex regex{"vout(\\d+)"};
	std::smatch results;
	if (std::regex_match(contents, results, regex))
	{
	// Verify 2 match results: entire match and one sub-match
	if (results.size() == 2)
	{
	// Get sub-match that contains the page number + 1
	std::string pageStr = results.str(1);
	page = std::stoul(pageStr) - 1;
	}
	}
	}
	catch (...)
	{
	// Ignore error. If this file is needed for pgood fault detection, an
	// error will occur later when the necessary mapping is missing. Avoid
	// logging unnecessary errors for files that may not be required.
	}
	return page;
	}

	} // namespace phosphor::power::sequencer