1 /**
2 * Copyright © 2022 IBM Corporation
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 #include "fan.hpp"
17
18 #include "sdbusplus.hpp"
19
20 #include <nlohmann/json.hpp>
21 #include <phosphor-logging/lg2.hpp>
22 #include <sdbusplus/bus.hpp>
23
24 #include <format>
25
26 namespace phosphor::fan::control::json
27 {
28
29 using json = nlohmann::json;
30
31 constexpr auto FAN_SENSOR_PATH = "/xyz/openbmc_project/sensors/fan_tach/";
32 constexpr auto FAN_TARGET_PROPERTY = "Target";
33
Fan(const json & jsonObj)34 Fan::Fan(const json& jsonObj) :
35 ConfigBase(jsonObj), _bus(util::SDBusPlus::getBus())
36 {
37 setInterface(jsonObj);
38 setSensors(jsonObj);
39 setZone(jsonObj);
40 }
41
setInterface(const json & jsonObj)42 void Fan::setInterface(const json& jsonObj)
43 {
44 if (!jsonObj.contains("target_interface"))
45 {
46 lg2::error("Missing required fan sensor target interface", "JSON",
47 jsonObj.dump());
48 throw std::runtime_error(
49 "Missing required fan sensor target interface");
50 }
51 _interface = jsonObj["target_interface"].get<std::string>();
52 }
53
setSensors(const json & jsonObj)54 void Fan::setSensors(const json& jsonObj)
55 {
56 if (!jsonObj.contains("sensors"))
57 {
58 lg2::error("Missing required fan sensors list", "JSON", jsonObj.dump());
59 throw std::runtime_error("Missing required fan sensors list");
60 }
61 std::string path;
62 for (const auto& sensor : jsonObj["sensors"])
63 {
64 if (!jsonObj.contains("target_path"))
65 {
66 // If target_path is not set in configuration,
67 // it is default to /xyz/openbmc_project/sensors/fan_tach/
68 path = FAN_SENSOR_PATH + sensor.get<std::string>();
69 }
70 else
71 {
72 path = jsonObj["target_path"].get<std::string>() +
73 sensor.get<std::string>();
74 }
75
76 auto service = util::SDBusPlus::getService(_bus, path, _interface);
77 _sensors[path] = service;
78 }
79 // All sensors associated with this fan are set to the same target,
80 // so only need to read target property from one of them
81 if (!path.empty())
82 {
83 _target = util::SDBusPlus::getProperty<uint64_t>(
84 _bus, _sensors.at(path), path, _interface, FAN_TARGET_PROPERTY);
85 }
86 }
87
setZone(const json & jsonObj)88 void Fan::setZone(const json& jsonObj)
89 {
90 if (!jsonObj.contains("zone"))
91 {
92 lg2::error("Missing required fan zone", "JSON", jsonObj.dump());
93 throw std::runtime_error("Missing required fan zone");
94 }
95 _zone = jsonObj["zone"].get<std::string>();
96 }
97
setTarget(uint64_t target)98 void Fan::setTarget(uint64_t target)
99 {
100 if ((_target == target) || !_lockedTargets.empty())
101 {
102 return;
103 }
104
105 for (const auto& sensor : _sensors)
106 {
107 auto value = target;
108 try
109 {
110 util::SDBusPlus::setProperty<uint64_t>(
111 _bus, sensor.second, sensor.first, _interface,
112 FAN_TARGET_PROPERTY, std::move(value));
113 }
114 catch (const sdbusplus::exception_t&)
115 {
116 throw util::DBusPropertyError{
117 std::format("Failed to set target for fan {}", _name).c_str(),
118 sensor.second, sensor.first, _interface, FAN_TARGET_PROPERTY};
119 }
120 }
121 _target = target;
122 }
123
lockTarget(uint64_t target)124 void Fan::lockTarget(uint64_t target)
125 {
126 // if multiple locks, take highest, else allow only the
127 // first lock to lower the target
128 if (target >= _target || _lockedTargets.empty())
129 {
130 // setTarget wont work if any locked targets exist
131 decltype(_lockedTargets) temp;
132 _lockedTargets.swap(temp);
133
134 setTarget(target);
135 _lockedTargets.swap(temp);
136 }
137
138 _lockedTargets.push_back(target);
139 }
140
unlockTarget(uint64_t target)141 void Fan::unlockTarget(uint64_t target)
142 {
143 // find and remove the requested lock
144 auto itr(std::find_if(
145 _lockedTargets.begin(), _lockedTargets.end(),
146 [target](auto lockedTarget) { return target == lockedTarget; }));
147
148 if (_lockedTargets.end() != itr)
149 {
150 _lockedTargets.erase(itr);
151
152 // if additional locks, re-lock at next-highest target
153 if (!_lockedTargets.empty())
154 {
155 itr =
156 std::max_element(_lockedTargets.begin(), _lockedTargets.end());
157
158 // setTarget wont work if any locked targets exist
159 decltype(_lockedTargets) temp;
160 _lockedTargets.swap(temp);
161 setTarget(*itr);
162 _lockedTargets.swap(temp);
163 }
164 }
165 }
166
167 } // namespace phosphor::fan::control::json
168