1 #include "occ_device.hpp"
2 
3 #include "occ_manager.hpp"
4 #include "occ_status.hpp"
5 
6 #include <phosphor-logging/log.hpp>
7 
8 #include <filesystem>
9 #include <iostream>
10 
11 namespace open_power
12 {
13 namespace occ
14 {
15 
16 using namespace phosphor::logging;
17 
18 void Device::setActive(bool active)
19 {
20     std::string data = active ? "1" : "0";
21     auto activeFile = devPath / "occ_active";
22     try
23     {
24         write(activeFile, data);
25     }
26     catch (const std::exception& e)
27     {
28         log<level::ERR>(fmt::format("Failed to set {} active: {}",
29                                     devPath.c_str(), e.what())
30                             .c_str());
31     }
32 }
33 
34 std::string Device::getPathBack(const fs::path& path)
35 {
36     if (path.empty())
37     {
38         return std::string();
39     }
40 
41     // Points to the last element in the path
42     auto conf = --path.end();
43 
44     if (conf->empty() && conf != path.begin())
45     {
46         return *(--conf);
47     }
48     else
49     {
50         return *conf;
51     }
52 }
53 
54 bool Device::active() const
55 {
56     return readBinary("occ_active");
57 }
58 
59 bool Device::master() const
60 {
61     return readBinary("occ_master");
62 }
63 
64 bool Device::readBinary(const std::string& fileName) const
65 {
66     int v = 0;
67     if (statusObject.occActive())
68     {
69         auto filePath = devPath / fileName;
70         std::ifstream file(filePath, std::ios::in);
71         if (!file)
72         {
73             return false;
74         }
75 
76         file >> v;
77         file.close();
78     }
79     return v == 1;
80 }
81 
82 void Device::errorCallback(bool error)
83 {
84     if (error)
85     {
86         statusObject.deviceError();
87     }
88 }
89 
90 #ifdef PLDM
91 void Device::timeoutCallback(bool error)
92 {
93     if (error)
94     {
95         managerObject.sbeTimeout(instance);
96     }
97 }
98 #endif
99 
100 void Device::throttleProcTempCallback(bool error)
101 {
102     statusObject.throttleProcTemp(error);
103 }
104 
105 void Device::throttleProcPowerCallback(bool error)
106 {
107     statusObject.throttleProcPower(error);
108 }
109 
110 void Device::throttleMemTempCallback(bool error)
111 {
112     statusObject.throttleMemTemp(error);
113 }
114 
115 fs::path Device::getFilenameByRegex(fs::path basePath,
116                                     const std::regex& expr) const
117 {
118     try
119     {
120         for (auto& file : fs::directory_iterator(basePath))
121         {
122             if (std::regex_search(file.path().string(), expr))
123             {
124                 // Found match
125                 return file;
126             }
127         }
128     }
129     catch (const fs::filesystem_error& e)
130     {
131         log<level::ERR>(
132             fmt::format("getFilenameByRegex: Failed to get filename: {}",
133                         e.what())
134                 .c_str());
135     }
136 
137     // Return empty path
138     return fs::path{};
139 }
140 
141 } // namespace occ
142 } // namespace open_power
143