16714a25aSJames Feist /*
26714a25aSJames Feist // Copyright (c) 2017 Intel Corporation
36714a25aSJames Feist //
46714a25aSJames Feist // Licensed under the Apache License, Version 2.0 (the "License");
56714a25aSJames Feist // you may not use this file except in compliance with the License.
66714a25aSJames Feist // You may obtain a copy of the License at
76714a25aSJames Feist //
86714a25aSJames Feist //      http://www.apache.org/licenses/LICENSE-2.0
96714a25aSJames Feist //
106714a25aSJames Feist // Unless required by applicable law or agreed to in writing, software
116714a25aSJames Feist // distributed under the License is distributed on an "AS IS" BASIS,
126714a25aSJames Feist // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
136714a25aSJames Feist // See the License for the specific language governing permissions and
146714a25aSJames Feist // limitations under the License.
156714a25aSJames Feist */
166714a25aSJames Feist 
178a57ec09SEd Tanous #include <HwmonTempSensor.hpp>
188a57ec09SEd Tanous #include <Utils.hpp>
196714a25aSJames Feist #include <boost/algorithm/string/predicate.hpp>
206714a25aSJames Feist #include <boost/algorithm/string/replace.hpp>
2196e97db7SPatrick Venture #include <boost/container/flat_map.hpp>
226714a25aSJames Feist #include <boost/container/flat_set.hpp>
2338fb5983SJames Feist #include <sdbusplus/asio/connection.hpp>
2438fb5983SJames Feist #include <sdbusplus/asio/object_server.hpp>
2538fb5983SJames Feist #include <sdbusplus/bus/match.hpp>
2638fb5983SJames Feist 
2738fb5983SJames Feist #include <array>
2824f02f24SJames Feist #include <filesystem>
296714a25aSJames Feist #include <fstream>
3096e97db7SPatrick Venture #include <functional>
3196e97db7SPatrick Venture #include <memory>
326714a25aSJames Feist #include <regex>
3396e97db7SPatrick Venture #include <stdexcept>
3496e97db7SPatrick Venture #include <string>
3596e97db7SPatrick Venture #include <utility>
3696e97db7SPatrick Venture #include <variant>
3796e97db7SPatrick Venture #include <vector>
386714a25aSJames Feist 
398a57ec09SEd Tanous static constexpr bool debug = false;
4087bc67f7SJeff Lin static constexpr float pollRateDefault = 0.5;
416714a25aSJames Feist 
42cf3bce6eSJames Feist namespace fs = std::filesystem;
43*7ea918f2SZev Weiss static constexpr std::array<const char*, 16> sensorTypes = {
44381636e2SGilbert Chen     "xyz.openbmc_project.Configuration.EMC1412",
458b3f7d40SAlex Qiu     "xyz.openbmc_project.Configuration.EMC1413",
46381636e2SGilbert Chen     "xyz.openbmc_project.Configuration.EMC1414",
478b3f7d40SAlex Qiu     "xyz.openbmc_project.Configuration.MAX31725",
488b3f7d40SAlex Qiu     "xyz.openbmc_project.Configuration.MAX31730",
4916e7af1dSJason Ling     "xyz.openbmc_project.Configuration.MAX6581",
503840d0adSJosh Lehan     "xyz.openbmc_project.Configuration.MAX6654",
518fb0a013SJosh Lehan     "xyz.openbmc_project.Configuration.SBTSI",
525a3b3f8aSKonstantin Aladyshev     "xyz.openbmc_project.Configuration.LM95234",
5355ab2afbSJohn Wang     "xyz.openbmc_project.Configuration.TMP112",
543546adb9SPatrick Venture     "xyz.openbmc_project.Configuration.TMP175",
558b3f7d40SAlex Qiu     "xyz.openbmc_project.Configuration.TMP421",
568b3f7d40SAlex Qiu     "xyz.openbmc_project.Configuration.TMP441",
5734fc75a7SKonstantin Aladyshev     "xyz.openbmc_project.Configuration.LM75A",
58*7ea918f2SZev Weiss     "xyz.openbmc_project.Configuration.TMP75",
59*7ea918f2SZev Weiss     "xyz.openbmc_project.Configuration.W83773G"};
606714a25aSJames Feist 
616714a25aSJames Feist void createSensors(
626714a25aSJames Feist     boost::asio::io_service& io, sdbusplus::asio::object_server& objectServer,
63f3fd1915SYong Li     boost::container::flat_map<std::string, std::shared_ptr<HwmonTempSensor>>&
646714a25aSJames Feist         sensors,
656714a25aSJames Feist     std::shared_ptr<sdbusplus::asio::connection>& dbusConnection,
665591cf08SJames Feist     const std::shared_ptr<boost::container::flat_set<std::string>>&
676714a25aSJames Feist         sensorsChanged)
686714a25aSJames Feist {
69df515159SJames Feist     auto getter = std::make_shared<GetSensorConfiguration>(
70df515159SJames Feist         dbusConnection,
71df515159SJames Feist         std::move([&io, &objectServer, &sensors, &dbusConnection,
725591cf08SJames Feist                    sensorsChanged](
73df515159SJames Feist                       const ManagedObjectType& sensorConfigurations) {
746714a25aSJames Feist             bool firstScan = sensorsChanged == nullptr;
75df515159SJames Feist 
766714a25aSJames Feist             std::vector<fs::path> paths;
77df515159SJames Feist             if (!findFiles(fs::path("/sys/class/hwmon"), R"(temp\d+_input)",
78df515159SJames Feist                            paths))
796714a25aSJames Feist             {
806714a25aSJames Feist                 std::cerr << "No temperature sensors in system\n";
816714a25aSJames Feist                 return;
826714a25aSJames Feist             }
836714a25aSJames Feist 
8437266ca9SJames Feist             boost::container::flat_set<std::string> directories;
8537266ca9SJames Feist 
86df515159SJames Feist             // iterate through all found temp sensors, and try to match them
87df515159SJames Feist             // with configuration
886714a25aSJames Feist             for (auto& path : paths)
896714a25aSJames Feist             {
906714a25aSJames Feist                 std::smatch match;
9137266ca9SJames Feist                 const std::string& pathStr = path.string();
926714a25aSJames Feist                 auto directory = path.parent_path();
936714a25aSJames Feist 
9437266ca9SJames Feist                 auto ret = directories.insert(directory.string());
9537266ca9SJames Feist                 if (!ret.second)
966714a25aSJames Feist                 {
9737266ca9SJames Feist                     continue; // already searched this path
9837266ca9SJames Feist                 }
9937266ca9SJames Feist 
100b6c0b914SJames Feist                 fs::path device = directory / "device";
10137266ca9SJames Feist                 std::string deviceName = fs::canonical(device).stem();
1028a57ec09SEd Tanous                 auto findHyphen = deviceName.find('-');
10337266ca9SJames Feist                 if (findHyphen == std::string::npos)
10437266ca9SJames Feist                 {
10537266ca9SJames Feist                     std::cerr << "found bad device " << deviceName << "\n";
1066714a25aSJames Feist                     continue;
1076714a25aSJames Feist                 }
10837266ca9SJames Feist                 std::string busStr = deviceName.substr(0, findHyphen);
10937266ca9SJames Feist                 std::string addrStr = deviceName.substr(findHyphen + 1);
11037266ca9SJames Feist 
11137266ca9SJames Feist                 size_t bus = 0;
11237266ca9SJames Feist                 size_t addr = 0;
11337266ca9SJames Feist                 try
1146714a25aSJames Feist                 {
11537266ca9SJames Feist                     bus = std::stoi(busStr);
1168a57ec09SEd Tanous                     addr = std::stoi(addrStr, nullptr, 16);
11737266ca9SJames Feist                 }
118b6c0b914SJames Feist                 catch (std::invalid_argument&)
11937266ca9SJames Feist                 {
1206714a25aSJames Feist                     continue;
1216714a25aSJames Feist                 }
1226714a25aSJames Feist                 const SensorData* sensorData = nullptr;
1236714a25aSJames Feist                 const std::string* interfacePath = nullptr;
12437266ca9SJames Feist                 const char* sensorType = nullptr;
1258b3f7d40SAlex Qiu                 const SensorBaseConfiguration* baseConfiguration = nullptr;
1268b3f7d40SAlex Qiu                 const SensorBaseConfigMap* baseConfigMap = nullptr;
12737266ca9SJames Feist 
128df515159SJames Feist                 for (const std::pair<sdbusplus::message::object_path,
129df515159SJames Feist                                      SensorData>& sensor : sensorConfigurations)
13037266ca9SJames Feist                 {
13137266ca9SJames Feist                     sensorData = &(sensor.second);
1329ced0a38SJae Hyun Yoo                     for (const char* type : sensorTypes)
1336714a25aSJames Feist                     {
1346714a25aSJames Feist                         auto sensorBase = sensorData->find(type);
1356714a25aSJames Feist                         if (sensorBase != sensorData->end())
1366714a25aSJames Feist                         {
1376714a25aSJames Feist                             baseConfiguration = &(*sensorBase);
1386714a25aSJames Feist                             sensorType = type;
1396714a25aSJames Feist                             break;
1406714a25aSJames Feist                         }
1416714a25aSJames Feist                     }
1426714a25aSJames Feist                     if (baseConfiguration == nullptr)
1436714a25aSJames Feist                     {
14437266ca9SJames Feist                         std::cerr << "error finding base configuration for "
14537266ca9SJames Feist                                   << deviceName << "\n";
14637266ca9SJames Feist                         continue;
14737266ca9SJames Feist                     }
1488b3f7d40SAlex Qiu                     baseConfigMap = &baseConfiguration->second;
1498b3f7d40SAlex Qiu                     auto configurationBus = baseConfigMap->find("Bus");
1508b3f7d40SAlex Qiu                     auto configurationAddress = baseConfigMap->find("Address");
15137266ca9SJames Feist 
1528b3f7d40SAlex Qiu                     if (configurationBus == baseConfigMap->end() ||
1538b3f7d40SAlex Qiu                         configurationAddress == baseConfigMap->end())
15437266ca9SJames Feist                     {
1558b3f7d40SAlex Qiu                         std::cerr << "error finding bus or address in "
1568b3f7d40SAlex Qiu                                      "configuration\n";
15737266ca9SJames Feist                         continue;
15837266ca9SJames Feist                     }
15937266ca9SJames Feist 
1603eb82629SJames Feist                     if (std::get<uint64_t>(configurationBus->second) != bus ||
161df515159SJames Feist                         std::get<uint64_t>(configurationAddress->second) !=
162df515159SJames Feist                             addr)
16337266ca9SJames Feist                     {
16437266ca9SJames Feist                         continue;
16537266ca9SJames Feist                     }
16637266ca9SJames Feist 
16737266ca9SJames Feist                     interfacePath = &(sensor.first.str);
16837266ca9SJames Feist                     break;
16937266ca9SJames Feist                 }
17037266ca9SJames Feist                 if (interfacePath == nullptr)
17137266ca9SJames Feist                 {
172df515159SJames Feist                     std::cerr << "failed to find match for " << deviceName
173df515159SJames Feist                               << "\n";
1746714a25aSJames Feist                     continue;
1756714a25aSJames Feist                 }
1766714a25aSJames Feist 
1778b3f7d40SAlex Qiu                 auto findSensorName = baseConfigMap->find("Name");
1788b3f7d40SAlex Qiu                 if (findSensorName == baseConfigMap->end())
1796714a25aSJames Feist                 {
1806714a25aSJames Feist                     std::cerr << "could not determine configuration name for "
18137266ca9SJames Feist                               << deviceName << "\n";
1826714a25aSJames Feist                     continue;
1836714a25aSJames Feist                 }
184df515159SJames Feist                 std::string sensorName =
185df515159SJames Feist                     std::get<std::string>(findSensorName->second);
1866714a25aSJames Feist                 // on rescans, only update sensors we were signaled by
1876714a25aSJames Feist                 auto findSensor = sensors.find(sensorName);
1886714a25aSJames Feist                 if (!firstScan && findSensor != sensors.end())
1896714a25aSJames Feist                 {
1906714a25aSJames Feist                     bool found = false;
191df515159SJames Feist                     for (auto it = sensorsChanged->begin();
192df515159SJames Feist                          it != sensorsChanged->end(); it++)
1936714a25aSJames Feist                     {
1946714a25aSJames Feist                         if (boost::ends_with(*it, findSensor->second->name))
1956714a25aSJames Feist                         {
1966714a25aSJames Feist                             sensorsChanged->erase(it);
1976714a25aSJames Feist                             findSensor->second = nullptr;
1986714a25aSJames Feist                             found = true;
1996714a25aSJames Feist                             break;
2006714a25aSJames Feist                         }
2016714a25aSJames Feist                     }
2026714a25aSJames Feist                     if (!found)
2036714a25aSJames Feist                     {
2046714a25aSJames Feist                         continue;
2056714a25aSJames Feist                     }
2066714a25aSJames Feist                 }
2076714a25aSJames Feist                 std::vector<thresholds::Threshold> sensorThresholds;
2089ced0a38SJae Hyun Yoo                 if (!parseThresholdsFromConfig(*sensorData, sensorThresholds))
2096714a25aSJames Feist                 {
210df515159SJames Feist                     std::cerr << "error populating thresholds for "
211df515159SJames Feist                               << sensorName << "\n";
2126714a25aSJames Feist                 }
21387bc67f7SJeff Lin 
21487bc67f7SJeff Lin                 auto findPollRate = baseConfiguration->second.find("PollRate");
21587bc67f7SJeff Lin                 float pollRate = pollRateDefault;
21687bc67f7SJeff Lin                 if (findPollRate != baseConfiguration->second.end())
21787bc67f7SJeff Lin                 {
21887bc67f7SJeff Lin                     pollRate = std::visit(VariantToFloatVisitor(),
21987bc67f7SJeff Lin                                           findPollRate->second);
22087bc67f7SJeff Lin                     if (pollRate <= 0.0f)
22187bc67f7SJeff Lin                     {
22287bc67f7SJeff Lin                         pollRate = pollRateDefault; // polling time too short
22387bc67f7SJeff Lin                     }
22487bc67f7SJeff Lin                 }
22587bc67f7SJeff Lin 
226f9b01b6dSJames Feist                 auto findPowerOn = baseConfiguration->second.find("PowerState");
227f9b01b6dSJames Feist                 PowerState readState = PowerState::always;
228f9b01b6dSJames Feist                 if (findPowerOn != baseConfiguration->second.end())
229f9b01b6dSJames Feist                 {
230f9b01b6dSJames Feist                     std::string powerState = std::visit(
231f9b01b6dSJames Feist                         VariantToStringVisitor(), findPowerOn->second);
232f9b01b6dSJames Feist                     setReadState(powerState, readState);
233f9b01b6dSJames Feist                 }
234100c20bfSJason Ling 
235100c20bfSJason Ling                 auto permitSet = getPermitSet(*baseConfigMap);
2368b3f7d40SAlex Qiu                 auto& sensor = sensors[sensorName];
2378b3f7d40SAlex Qiu                 sensor = nullptr;
238100c20bfSJason Ling                 auto hwmonFile = getFullHwmonFilePath(directory.string(),
239100c20bfSJason Ling                                                       "temp1", permitSet);
240100c20bfSJason Ling                 if (hwmonFile)
241100c20bfSJason Ling                 {
242f3fd1915SYong Li                     sensor = std::make_shared<HwmonTempSensor>(
243100c20bfSJason Ling                         *hwmonFile, sensorType, objectServer, dbusConnection,
24487bc67f7SJeff Lin                         io, sensorName, std::move(sensorThresholds), pollRate,
245100c20bfSJason Ling                         *interfacePath, readState);
246f3fd1915SYong Li                     sensor->setupRead();
247100c20bfSJason Ling                 }
2488b3f7d40SAlex Qiu                 // Looking for keys like "Name1" for temp2_input,
2498b3f7d40SAlex Qiu                 // "Name2" for temp3_input, etc.
2508b3f7d40SAlex Qiu                 int i = 0;
2518b3f7d40SAlex Qiu                 while (true)
25237266ca9SJames Feist                 {
2538b3f7d40SAlex Qiu                     ++i;
2548b3f7d40SAlex Qiu                     auto findKey =
2558b8bcc87SJason Ling                         baseConfigMap->find("Name" + std::to_string(i));
2568b3f7d40SAlex Qiu                     if (findKey == baseConfigMap->end())
2578b3f7d40SAlex Qiu                     {
2588b3f7d40SAlex Qiu                         break;
25937266ca9SJames Feist                     }
2608b3f7d40SAlex Qiu                     std::string sensorName =
2618b3f7d40SAlex Qiu                         std::get<std::string>(findKey->second);
262100c20bfSJason Ling                     hwmonFile = getFullHwmonFilePath(
263100c20bfSJason Ling                         directory.string(), "temp" + std::to_string(i + 1),
264100c20bfSJason Ling                         permitSet);
265100c20bfSJason Ling                     if (hwmonFile)
266100c20bfSJason Ling                     {
2678b3f7d40SAlex Qiu                         auto& sensor = sensors[sensorName];
2688b3f7d40SAlex Qiu                         sensor = nullptr;
269f3fd1915SYong Li                         sensor = std::make_shared<HwmonTempSensor>(
270100c20bfSJason Ling                             *hwmonFile, sensorType, objectServer,
271100c20bfSJason Ling                             dbusConnection, io, sensorName,
27287bc67f7SJeff Lin                             std::vector<thresholds::Threshold>(), pollRate,
273f9b01b6dSJames Feist                             *interfacePath, readState);
274f3fd1915SYong Li                         sensor->setupRead();
2758b3f7d40SAlex Qiu                     }
2766714a25aSJames Feist                 }
277100c20bfSJason Ling             }
278df515159SJames Feist         }));
279df515159SJames Feist     getter->getConfiguration(
280df515159SJames Feist         std::vector<std::string>(sensorTypes.begin(), sensorTypes.end()));
2816714a25aSJames Feist }
2826714a25aSJames Feist 
283b6c0b914SJames Feist int main()
2846714a25aSJames Feist {
2856714a25aSJames Feist     boost::asio::io_service io;
2866714a25aSJames Feist     auto systemBus = std::make_shared<sdbusplus::asio::connection>(io);
2876714a25aSJames Feist     systemBus->request_name("xyz.openbmc_project.HwmonTempSensor");
2886714a25aSJames Feist     sdbusplus::asio::object_server objectServer(systemBus);
289f3fd1915SYong Li     boost::container::flat_map<std::string, std::shared_ptr<HwmonTempSensor>>
2906714a25aSJames Feist         sensors;
2916714a25aSJames Feist     std::vector<std::unique_ptr<sdbusplus::bus::match::match>> matches;
2925591cf08SJames Feist     auto sensorsChanged =
2935591cf08SJames Feist         std::make_shared<boost::container::flat_set<std::string>>();
2946714a25aSJames Feist 
2956714a25aSJames Feist     io.post([&]() {
2966714a25aSJames Feist         createSensors(io, objectServer, sensors, systemBus, nullptr);
2976714a25aSJames Feist     });
2986714a25aSJames Feist 
2996714a25aSJames Feist     boost::asio::deadline_timer filterTimer(io);
3006714a25aSJames Feist     std::function<void(sdbusplus::message::message&)> eventHandler =
3016714a25aSJames Feist         [&](sdbusplus::message::message& message) {
3026714a25aSJames Feist             if (message.is_method_error())
3036714a25aSJames Feist             {
3046714a25aSJames Feist                 std::cerr << "callback method error\n";
3056714a25aSJames Feist                 return;
3066714a25aSJames Feist             }
3076714a25aSJames Feist             sensorsChanged->insert(message.get_path());
3086714a25aSJames Feist             // this implicitly cancels the timer
3096714a25aSJames Feist             filterTimer.expires_from_now(boost::posix_time::seconds(1));
3106714a25aSJames Feist 
3116714a25aSJames Feist             filterTimer.async_wait([&](const boost::system::error_code& ec) {
3126714a25aSJames Feist                 if (ec == boost::asio::error::operation_aborted)
3136714a25aSJames Feist                 {
3146714a25aSJames Feist                     /* we were canceled*/
3156714a25aSJames Feist                     return;
3166714a25aSJames Feist                 }
3178a57ec09SEd Tanous                 if (ec)
3186714a25aSJames Feist                 {
3196714a25aSJames Feist                     std::cerr << "timer error\n";
3206714a25aSJames Feist                     return;
3216714a25aSJames Feist                 }
3226714a25aSJames Feist                 createSensors(io, objectServer, sensors, systemBus,
3236714a25aSJames Feist                               sensorsChanged);
3246714a25aSJames Feist             });
3256714a25aSJames Feist         };
3266714a25aSJames Feist 
3279ced0a38SJae Hyun Yoo     for (const char* type : sensorTypes)
3286714a25aSJames Feist     {
3296714a25aSJames Feist         auto match = std::make_unique<sdbusplus::bus::match::match>(
3306714a25aSJames Feist             static_cast<sdbusplus::bus::bus&>(*systemBus),
3316714a25aSJames Feist             "type='signal',member='PropertiesChanged',path_namespace='" +
3329ced0a38SJae Hyun Yoo                 std::string(inventoryPath) + "',arg0namespace='" + type + "'",
3336714a25aSJames Feist             eventHandler);
3346714a25aSJames Feist         matches.emplace_back(std::move(match));
3356714a25aSJames Feist     }
3366714a25aSJames Feist 
3376714a25aSJames Feist     io.run();
3386714a25aSJames Feist }
339