1 #include "config.h"
2
3 #include "occ_command.hpp"
4
5 #include <errno.h>
6 #include <fcntl.h>
7 #include <unistd.h>
8
9 #include <org/open_power/OCC/Device/error.hpp>
10 #include <phosphor-logging/elog-errors.hpp>
11 #include <phosphor-logging/elog.hpp>
12 #include <phosphor-logging/log.hpp>
13
14 #include <algorithm>
15 #include <format>
16 #include <memory>
17 #include <string>
18
19 // #define TRACE_PACKETS
20
21 namespace open_power
22 {
23 namespace occ
24 {
25
26 using namespace phosphor::logging;
27
28 // Trace block of data in hex
dump_hex(const std::vector<std::uint8_t> & data,const unsigned int data_len)29 void dump_hex(const std::vector<std::uint8_t>& data,
30 const unsigned int data_len)
31 {
32 unsigned int dump_length = data.size();
33 if ((data_len > 0) && (data_len < dump_length))
34 {
35 dump_length = data_len;
36 }
37 std::string s;
38 for (uint32_t i = 0; i < dump_length; i++)
39 {
40 if (i % 16 == 0)
41 {
42 s += std::format("{:04X}: ", i);
43 }
44 else if (i % 4 == 0)
45 {
46 s += " ";
47 }
48
49 s += std::format("{:02X}", data.at(i));
50
51 if ((i % 16 == 15) || (i == (dump_length - 1)))
52 {
53 log<level::INFO>(s.c_str());
54 s.clear();
55 }
56 }
57 }
58
OccCommand(uint8_t instance,const char * path)59 OccCommand::OccCommand(uint8_t instance, const char* path) :
60 occInstance(instance), path(path),
61 devicePath(OCC_DEV_PATH + std::to_string((this->path.back() - '0') + 1)),
62 activeStatusSignal(
63 utils::getBus(),
64 sdbusRule::propertiesChanged(path, "org.open_power.OCC.Status"),
65 std::bind(std::mem_fn(&OccCommand::activeStatusEvent), this,
66 std::placeholders::_1))
67 {
68 log<level::DEBUG>(
69 std::format("OccCommand::OccCommand(path={}, devicePath={}", this->path,
70 devicePath)
71 .c_str());
72 }
73
openDevice()74 void OccCommand::openDevice()
75 {
76 using namespace sdbusplus::org::open_power::OCC::Device::Error;
77
78 log<level::DEBUG>(
79 std::format("OccCommand::openDevice: calling open {}", devicePath)
80 .c_str());
81 fd = open(devicePath.c_str(), O_RDWR | O_NONBLOCK);
82 if (fd < 0)
83 {
84 const int openErrno = errno;
85 log<level::ERR>(
86 std::format(
87 "OccCommand::openDevice: open failed (errno={}, path={})",
88 openErrno, devicePath)
89 .c_str());
90 }
91 else
92 {
93 log<level::DEBUG>("OccCommand::openDevice: open success");
94 }
95
96 return;
97 }
98
closeDevice()99 void OccCommand::closeDevice()
100 {
101 if (fd >= 0)
102 {
103 log<level::DEBUG>("OccCommand::closeDevice: calling close()");
104 close(fd);
105 fd = -1;
106 }
107 }
108
send(const std::vector<uint8_t> & command,std::vector<uint8_t> & response)109 CmdStatus OccCommand::send(const std::vector<uint8_t>& command,
110 std::vector<uint8_t>& response)
111 {
112 using namespace sdbusplus::org::open_power::OCC::Device::Error;
113 CmdStatus status = CmdStatus::FAILURE;
114
115 response.clear();
116
117 log<level::DEBUG>("OccCommand::send: calling openDevice()");
118 openDevice();
119
120 if (fd < 0)
121 {
122 // OCC is inactive; empty response
123 return CmdStatus::COMM_FAILURE;
124 }
125
126 const uint8_t cmd_type = command[0];
127 #ifdef TRACE_PACKETS
128 log<level::INFO>(
129 std::format("OCC{}: Sending 0x{:02X} command (length={}, {})",
130 occInstance, cmd_type, command.size(), devicePath)
131 .c_str());
132 dump_hex(command);
133 #else
134 log<level::DEBUG>("OccCommand::send: calling write()");
135 #endif
136
137 int retries = 1; // Allow a retry if a command fails to get valid response
138 do
139 {
140 auto rc = write(fd, command.data(), command.size());
141 const int writeErrno = errno;
142 if ((rc < 0) || (rc != (int)command.size()))
143 {
144 log<level::ERR>(
145 std::format(
146 "OccCommand::send: write(OCC{}, command:0x{:02X}) failed with errno={} (retries={})",
147 occInstance, cmd_type, writeErrno, retries)
148 .c_str());
149 status = CmdStatus::COMM_FAILURE;
150 // retry if available
151 continue;
152 }
153 else
154 {
155 log<level::DEBUG>("OccCommand::send: write succeeded");
156 }
157
158 // Now read the response. This would be the content of occ-sram
159 while (1)
160 {
161 uint8_t data{};
162 auto len = read(fd, &data, sizeof(data));
163 const int readErrno = errno;
164 if (len > 0)
165 {
166 response.emplace_back(data);
167 }
168 else if (len < 0 && readErrno == EAGAIN)
169 {
170 // We may have data coming still.
171 // This driver does not need a sleep for a retry.
172 continue;
173 }
174 else if (len == 0)
175 {
176 log<level::DEBUG>("OccCommand::send: read completed");
177 // We have read all that we can.
178 status = CmdStatus::SUCCESS;
179 break;
180 }
181 else
182 {
183 log<level::ERR>(
184 std::format(
185 "OccCommand::send: read(OCC{}, command:0x{:02X}) failed with errno={} (rspSize={}, retries={})",
186 occInstance, cmd_type, readErrno, response.size(),
187 retries)
188 .c_str());
189 status = CmdStatus::COMM_FAILURE;
190 break;
191 }
192 }
193 if (status != CmdStatus::SUCCESS)
194 {
195 // retry if available
196 continue;
197 }
198
199 if (response.size() > 2)
200 {
201 #ifdef TRACE_PACKETS
202 log<level::INFO>(
203 std::format(
204 "OCC{}: Received 0x{:02X} response (length={} w/checksum)",
205 occInstance, cmd_type, response.size())
206 .c_str());
207 dump_hex(response, 64);
208 #endif
209
210 // Validate checksum (last 2 bytes of response)
211 const unsigned int csumIndex = response.size() - 2;
212 const uint32_t rspChecksum = (response[csumIndex] << 8) +
213 response[csumIndex + 1];
214 uint32_t calcChecksum = 0;
215 for (unsigned int index = 0; index < csumIndex; ++index)
216 {
217 calcChecksum += response[index];
218 }
219 while (calcChecksum > 0xFFFF)
220 {
221 calcChecksum = (calcChecksum & 0xFFFF) + (calcChecksum >> 16);
222 }
223 if (calcChecksum != rspChecksum)
224 {
225 log<level::ERR>(
226 std::format("OCC{}: Checksum Mismatch: response "
227 "0x{:04X}, calculated 0x{:04X}",
228 occInstance, rspChecksum, calcChecksum)
229 .c_str());
230 dump_hex(response);
231 status = CmdStatus::COMM_FAILURE;
232 }
233 else
234 {
235 // Validate response was for the specified command
236 if (command[0] == response[1])
237 {
238 // Valid response received
239
240 // Strip off 2 byte checksum
241 response.pop_back();
242 response.pop_back();
243 break;
244 }
245 else
246 {
247 log<level::ERR>(
248 std::format(
249 "OccCommand::send: Response command mismatch "
250 "(sent: "
251 "0x{:02X}, rsp: 0x{:02X}, rsp seq#: 0x{:02X}",
252 command[0], response[1], response[0])
253 .c_str());
254 dump_hex(response, 64);
255 }
256 }
257 }
258 else
259 {
260 log<level::ERR>(
261 std::format(
262 "OccCommand::send: Invalid OCC{} response length: {}",
263 occInstance, response.size())
264 .c_str());
265 status = CmdStatus::FAILURE;
266 dump_hex(response);
267 }
268
269 if (retries > 0)
270 {
271 log<level::ERR>("OccCommand::send: Command will be retried");
272 response.clear();
273 }
274 } while (retries-- > 0);
275
276 closeDevice();
277
278 return status;
279 }
280
281 // Called at OCC Status change signal
activeStatusEvent(sdbusplus::message_t & msg)282 void OccCommand::activeStatusEvent(sdbusplus::message_t& msg)
283 {
284 std::string statusInterface;
285 std::map<std::string, std::variant<bool>> msgData;
286 msg.read(statusInterface, msgData);
287
288 auto propertyMap = msgData.find("OccActive");
289 if (propertyMap != msgData.end())
290 {
291 // Extract the OccActive property
292 if (std::get<bool>(propertyMap->second))
293 {
294 occActive = true;
295 }
296 else
297 {
298 occActive = false;
299
300 this->closeDevice();
301 }
302 }
303 return;
304 }
305
306 } // namespace occ
307 } // namespace open_power
308