blob: 8bd78512cf443e17d770a826b053ab22d183eaa4 [file] [log] [blame]
Enrico Granata60a818d2019-05-09 09:56:09 -07001// Copyright 2019 The Chromium OS Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include <memory>
6#include <string>
Harvey Yangc0d19d82019-07-01 12:17:34 +08007#include <vector>
Enrico Granata60a818d2019-05-09 09:56:09 -07008
9#include <base/files/file_util.h>
10#include <base/logging.h>
Harvey Yang9260b662019-08-12 15:48:03 +080011#include <base/strings/stringprintf.h>
Enrico Granata60a818d2019-05-09 09:56:09 -070012
Harvey Yang6698c862019-09-16 17:24:38 +080013#include "libmems/common_types.h"
Enrico Granata51cdb942019-06-18 16:40:17 -070014#include "libmems/iio_channel_impl.h"
15#include "libmems/iio_context_impl.h"
16#include "libmems/iio_device_impl.h"
Harvey Yang9260b662019-08-12 15:48:03 +080017#include "libmems/iio_device_trigger_impl.h"
Enrico Granata60a818d2019-05-09 09:56:09 -070018
Harvey Yangc0d19d82019-07-01 12:17:34 +080019#define ERROR_BUFFER_SIZE 256
20
Enrico Granata51cdb942019-06-18 16:40:17 -070021namespace libmems {
Enrico Granata60a818d2019-05-09 09:56:09 -070022
Harvey Yang75452e82019-10-02 16:57:01 +080023namespace {
24
Harvey Yang75452e82019-10-02 16:57:01 +080025constexpr int kNumSamples = 1;
26
27}; // namespace
28
Harvey Yang98ff1b32020-10-28 14:45:35 +080029// static
Harvey Yang9260b662019-08-12 15:48:03 +080030base::Optional<int> IioDeviceImpl::GetIdFromString(const char* id_str) {
31 return IioDevice::GetIdAfterPrefix(id_str, kDeviceIdPrefix);
32}
33
Harvey Yang98ff1b32020-10-28 14:45:35 +080034// static
Harvey Yang9260b662019-08-12 15:48:03 +080035std::string IioDeviceImpl::GetStringFromId(int id) {
36 return base::StringPrintf("%s%d", kDeviceIdPrefix, id);
37}
38
Enrico Granata60a818d2019-05-09 09:56:09 -070039IioDeviceImpl::IioDeviceImpl(IioContextImpl* ctx, iio_device* dev)
Harvey Yangc0d19d82019-07-01 12:17:34 +080040 : IioDevice(),
41 context_(ctx),
42 device_(dev),
Harvey Yang75452e82019-10-02 16:57:01 +080043 buffer_(nullptr, IioBufferDeleter) {
Enrico Granata60a818d2019-05-09 09:56:09 -070044 CHECK(context_);
45 CHECK(device_);
Harvey Yang5e6cb702020-01-15 10:57:44 +080046
Harvey Yang705e40f2020-11-19 15:42:44 +080047 log_prefix_ = base::StringPrintf("Device with id: %d and name: %s. ", GetId(),
48 (GetName() ? GetName() : "null"));
49
Harvey Yang9f48d812020-06-30 16:24:30 +080050 uint32_t chn_count = iio_device_get_channels_count(device_);
51 channels_.resize(chn_count);
52
53 for (uint32_t i = 0; i < chn_count; ++i) {
54 iio_channel* channel = iio_device_get_channel(device_, i);
55 if (channel == nullptr) {
Harvey Yang705e40f2020-11-19 15:42:44 +080056 LOG(WARNING) << log_prefix_ << "Unable to get " << i << "th channel";
Harvey Yang9f48d812020-06-30 16:24:30 +080057 continue;
58 }
59
Harvey Yang705e40f2020-11-19 15:42:44 +080060 channels_[i].chn = std::make_unique<IioChannelImpl>(
61 channel, GetId(), GetName() ? GetName() : "null");
Harvey Yang9f48d812020-06-30 16:24:30 +080062 channels_[i].chn_id = channels_[i].chn->GetId();
63 }
Enrico Granata60a818d2019-05-09 09:56:09 -070064}
65
66IioContext* IioDeviceImpl::GetContext() const {
67 return context_;
68}
69
70const char* IioDeviceImpl::GetName() const {
71 return iio_device_get_name(device_);
72}
73
Harvey Yang9260b662019-08-12 15:48:03 +080074int IioDeviceImpl::GetId() const {
75 const char* id_str = iio_device_get_id(device_);
76
77 auto id = GetIdFromString(id_str);
78 DCHECK(id.has_value());
79 return id.value();
Enrico Granata60a818d2019-05-09 09:56:09 -070080}
81
82base::FilePath IioDeviceImpl::GetPath() const {
Harvey Yang9260b662019-08-12 15:48:03 +080083 std::string id_str = GetStringFromId(GetId());
Harvey Yang36779e92020-08-26 10:46:15 +080084 auto path = base::FilePath(kSysDevString).Append(id_str);
Enrico Granata60a818d2019-05-09 09:56:09 -070085 CHECK(base::DirectoryExists(path));
86 return path;
87}
88
89base::Optional<std::string> IioDeviceImpl::ReadStringAttribute(
90 const std::string& name) const {
Harvey Yang9260b662019-08-12 15:48:03 +080091 char data[kReadAttrBufferSize] = {0};
Enrico Granata60a818d2019-05-09 09:56:09 -070092 ssize_t len = iio_device_attr_read(device_, name.c_str(), data, sizeof(data));
93 if (len < 0) {
Harvey Yang3b87b1d2020-12-04 15:38:20 +080094 LOG(WARNING) << log_prefix_ << "Attempting to read string attribute "
95 << name << " failed: " << len;
Enrico Granata60a818d2019-05-09 09:56:09 -070096 return base::nullopt;
97 }
98 return std::string(data, len);
99}
100
101base::Optional<int64_t> IioDeviceImpl::ReadNumberAttribute(
102 const std::string& name) const {
103 long long val = 0; // NOLINT(runtime/int)
104 int error = iio_device_attr_read_longlong(device_, name.c_str(), &val);
105 if (error) {
Harvey Yang3b87b1d2020-12-04 15:38:20 +0800106 LOG(WARNING) << log_prefix_ << "Attempting to read number attribute "
107 << name << " failed: " << error;
Enrico Granata60a818d2019-05-09 09:56:09 -0700108 return base::nullopt;
109 }
110 return val;
111}
112
Enrico Granatad2e57f42019-07-31 10:46:03 -0700113base::Optional<double> IioDeviceImpl::ReadDoubleAttribute(
114 const std::string& name) const {
115 double val = 0;
116 int error = iio_device_attr_read_double(device_, name.c_str(), &val);
117 if (error) {
Harvey Yang3b87b1d2020-12-04 15:38:20 +0800118 LOG(WARNING) << log_prefix_ << "Attempting to read double attribute "
119 << name << " failed: " << error;
Enrico Granatad2e57f42019-07-31 10:46:03 -0700120 return base::nullopt;
121 }
122 return val;
123}
124
Enrico Granata60a818d2019-05-09 09:56:09 -0700125bool IioDeviceImpl::WriteStringAttribute(const std::string& name,
Harvey Yang9260b662019-08-12 15:48:03 +0800126 const std::string& value) {
127 int error = iio_device_attr_write_raw(device_, name.c_str(), value.data(),
128 value.size());
129 if (error < 0) {
Harvey Yang3b87b1d2020-12-04 15:38:20 +0800130 LOG(WARNING) << log_prefix_ << "Attempting to write string attribute "
131 << name << " failed: " << error;
Enrico Granata60a818d2019-05-09 09:56:09 -0700132 return false;
133 }
134 return true;
135}
Enrico Granatad2e57f42019-07-31 10:46:03 -0700136
Enrico Granata60a818d2019-05-09 09:56:09 -0700137bool IioDeviceImpl::WriteNumberAttribute(const std::string& name,
Harvey Yang9260b662019-08-12 15:48:03 +0800138 int64_t value) {
139 int error = iio_device_attr_write_longlong(device_, name.c_str(), value);
Enrico Granata60a818d2019-05-09 09:56:09 -0700140 if (error) {
Harvey Yang3b87b1d2020-12-04 15:38:20 +0800141 LOG(WARNING) << log_prefix_ << "Attempting to write number attribute "
142 << name << " failed: " << error;
Enrico Granata60a818d2019-05-09 09:56:09 -0700143 return false;
144 }
145 return true;
146}
147
Harvey Yang9260b662019-08-12 15:48:03 +0800148bool IioDeviceImpl::WriteDoubleAttribute(const std::string& name,
149 double value) {
150 int error = iio_device_attr_write_double(device_, name.c_str(), value);
Enrico Granatad2e57f42019-07-31 10:46:03 -0700151 if (error) {
Harvey Yang3b87b1d2020-12-04 15:38:20 +0800152 LOG(WARNING) << log_prefix_ << "Attempting to write double attribute "
153 << name << " failed: " << error;
Enrico Granatad2e57f42019-07-31 10:46:03 -0700154 return false;
155 }
156 return true;
157}
158
Enrico Granata60a818d2019-05-09 09:56:09 -0700159iio_device* IioDeviceImpl::GetUnderlyingIioDevice() const {
160 return device_;
161}
162
163bool IioDeviceImpl::SetTrigger(IioDevice* trigger_device) {
Gwendal Grignou66393e22019-11-20 16:46:22 -0800164 // Reset the old - if any - and then add the new trigger.
165 int error = iio_device_set_trigger(device_, NULL);
166 if (error) {
Harvey Yang705e40f2020-11-19 15:42:44 +0800167 LOG(WARNING) << log_prefix_ << "Unable to clean trigger, error: " << error;
Gwendal Grignou66393e22019-11-20 16:46:22 -0800168 return false;
169 }
170 if (trigger_device == nullptr)
171 return true;
172
Harvey Yang9260b662019-08-12 15:48:03 +0800173 const iio_device* impl_device = nullptr;
174 int id = trigger_device->GetId();
175 if (id == -2) {
176 impl_device = iio_context_find_device(GetContext()->GetCurrentContext(),
177 kIioSysfsTrigger);
178 } else {
179 std::string id_str = IioDeviceTriggerImpl::GetStringFromId(id);
180 impl_device = iio_context_find_device(GetContext()->GetCurrentContext(),
181 id_str.c_str());
182 }
Enrico Granata60a818d2019-05-09 09:56:09 -0700183 if (!impl_device) {
Harvey Yang705e40f2020-11-19 15:42:44 +0800184 LOG(WARNING) << log_prefix_ << "Unable to find device " << id
185 << " in the current context";
Enrico Granata60a818d2019-05-09 09:56:09 -0700186 return false;
187 }
Gwendal Grignou66393e22019-11-20 16:46:22 -0800188
189 error = iio_device_set_trigger(device_, impl_device);
190 if (error) {
Harvey Yang705e40f2020-11-19 15:42:44 +0800191 LOG(WARNING) << log_prefix_ << "Unable to set trigger to be device "
192 << trigger_device->GetId() << ", error: " << error;
Enrico Granata60a818d2019-05-09 09:56:09 -0700193 return false;
194 }
195 return true;
196}
197
198IioDevice* IioDeviceImpl::GetTrigger() {
199 const iio_device* trigger;
200 int error = iio_device_get_trigger(device_, &trigger);
Harvey Yang74a18762020-12-30 11:09:13 +0800201 if (error)
Enrico Granata60a818d2019-05-09 09:56:09 -0700202 return nullptr;
Gwendal Grignou66393e22019-11-20 16:46:22 -0800203
204 if (trigger == nullptr)
205 return nullptr;
206
Harvey Yang9260b662019-08-12 15:48:03 +0800207 const char* id_str = iio_device_get_id(trigger);
208 auto id = IioDeviceTriggerImpl::GetIdFromString(id_str);
209
210 IioDevice* trigger_device = nullptr;
211 if (id.has_value())
212 trigger_device = GetContext()->GetTriggerById(id.value());
213
Enrico Granata60a818d2019-05-09 09:56:09 -0700214 if (trigger_device == nullptr) {
Harvey Yang705e40f2020-11-19 15:42:44 +0800215 LOG(WARNING) << log_prefix_ << "Has trigger device " << id_str
216 << ", which cannot be found in this context";
Enrico Granata60a818d2019-05-09 09:56:09 -0700217 }
Harvey Yang9260b662019-08-12 15:48:03 +0800218
Enrico Granata60a818d2019-05-09 09:56:09 -0700219 return trigger_device;
220}
221
Harvey Yangc0d19d82019-07-01 12:17:34 +0800222base::Optional<size_t> IioDeviceImpl::GetSampleSize() const {
223 ssize_t sample_size = iio_device_get_sample_size(device_);
224 if (sample_size < 0) {
Harvey Yang75452e82019-10-02 16:57:01 +0800225 char errMsg[kErrorBufferSize];
Harvey Yangc0d19d82019-07-01 12:17:34 +0800226 iio_strerror(errno, errMsg, sizeof(errMsg));
Harvey Yang705e40f2020-11-19 15:42:44 +0800227 LOG(WARNING) << log_prefix_ << "Unable to get sample size: " << errMsg;
Harvey Yangc0d19d82019-07-01 12:17:34 +0800228 return base::nullopt;
229 }
230
231 return static_cast<size_t>(sample_size);
232}
233
Enrico Granata60a818d2019-05-09 09:56:09 -0700234bool IioDeviceImpl::EnableBuffer(size_t count) {
235 if (!WriteNumberAttribute("buffer/length", count))
236 return false;
237 if (!WriteNumberAttribute("buffer/enable", 1))
238 return false;
239
240 return true;
241}
242
243bool IioDeviceImpl::DisableBuffer() {
244 return WriteNumberAttribute("buffer/enable", 0);
245}
246
247bool IioDeviceImpl::IsBufferEnabled(size_t* count) const {
248 bool enabled = (ReadNumberAttribute("buffer/enable").value_or(0) == 1);
249 if (enabled && count)
250 *count = ReadNumberAttribute("buffer/length").value_or(0);
251
252 return enabled;
253}
254
Harvey Yangdf365182021-01-16 23:43:45 +0800255bool IioDeviceImpl::CreateBuffer() {
256 if (buffer_)
257 return false;
258
259 buffer_.reset(iio_device_create_buffer(device_, kNumSamples, false));
260
261 if (!buffer_) {
262 char errMsg[kErrorBufferSize];
263 iio_strerror(errno, errMsg, sizeof(errMsg));
264 LOG(ERROR) << log_prefix_ << "Unable to allocate buffer: " << errMsg;
265 return false;
266 }
267
268 return true;
269}
270
Harvey Yange8b301b2020-05-19 14:43:03 +0800271base::Optional<int32_t> IioDeviceImpl::GetBufferFd() {
Harvey Yangdf365182021-01-16 23:43:45 +0800272 if (!buffer_)
Harvey Yange8b301b2020-05-19 14:43:03 +0800273 return base::nullopt;
274
275 int32_t fd = iio_buffer_get_poll_fd(buffer_.get());
276 if (fd < 0) {
Harvey Yang705e40f2020-11-19 15:42:44 +0800277 LOG(ERROR) << log_prefix_ << "Failed to get poll fd: " << fd;
Harvey Yange8b301b2020-05-19 14:43:03 +0800278 return base::nullopt;
279 }
280
281 return fd;
282}
283
Harvey Yang34c54d52020-05-20 13:34:20 +0800284base::Optional<IioDevice::IioSample> IioDeviceImpl::ReadSample() {
Harvey Yangdf365182021-01-16 23:43:45 +0800285 if (!buffer_)
Harvey Yang34c54d52020-05-20 13:34:20 +0800286 return base::nullopt;
Harvey Yangc0d19d82019-07-01 12:17:34 +0800287
288 ssize_t ret = iio_buffer_refill(buffer_.get());
289 if (ret < 0) {
Harvey Yang75452e82019-10-02 16:57:01 +0800290 char errMsg[kErrorBufferSize];
Harvey Yangc0d19d82019-07-01 12:17:34 +0800291 iio_strerror(-ret, errMsg, sizeof(errMsg));
Harvey Yang705e40f2020-11-19 15:42:44 +0800292 LOG(ERROR) << log_prefix_ << "Unable to refill buffer: " << errMsg;
Harvey Yangae53dc82019-07-25 18:11:20 +0800293
Harvey Yang34c54d52020-05-20 13:34:20 +0800294 return base::nullopt;
Harvey Yangc0d19d82019-07-01 12:17:34 +0800295 }
296
297 const auto buf_step = iio_buffer_step(buffer_.get());
298 size_t sample_size = GetSampleSize().value_or(0);
299
300 // There is something wrong when refilling the buffer.
301 if (buf_step != sample_size) {
Harvey Yang705e40f2020-11-19 15:42:44 +0800302 LOG(ERROR) << log_prefix_
303 << "sample_size doesn't match in refill: " << buf_step
Harvey Yangc0d19d82019-07-01 12:17:34 +0800304 << ", sample_size: " << sample_size;
305
Harvey Yang34c54d52020-05-20 13:34:20 +0800306 return base::nullopt;
Harvey Yangc0d19d82019-07-01 12:17:34 +0800307 }
308
309 uint8_t* start = reinterpret_cast<uint8_t*>(iio_buffer_start(buffer_.get()));
Harvey Yangc0d19d82019-07-01 12:17:34 +0800310
Harvey Yang34c54d52020-05-20 13:34:20 +0800311 return DeserializeSample(start);
Harvey Yangc0d19d82019-07-01 12:17:34 +0800312}
313
Harvey Yangdf365182021-01-16 23:43:45 +0800314void IioDeviceImpl::FreeBuffer() {
315 buffer_.reset();
316}
317
Harvey Yangc0d19d82019-07-01 12:17:34 +0800318// static
319void IioDeviceImpl::IioBufferDeleter(iio_buffer* buffer) {
320 iio_buffer_cancel(buffer);
321 iio_buffer_destroy(buffer);
322}
323
Harvey Yang34c54d52020-05-20 13:34:20 +0800324IioDevice::IioSample IioDeviceImpl::DeserializeSample(const uint8_t* src) {
Harvey Yang9f48d812020-06-30 16:24:30 +0800325 IioSample sample;
Harvey Yang34c54d52020-05-20 13:34:20 +0800326 int64_t pos = 0;
327
Harvey Yang9f48d812020-06-30 16:24:30 +0800328 auto channels = GetAllChannels();
329 for (int32_t i = 0; i < channels.size(); ++i) {
330 IioChannelImpl* chn = dynamic_cast<IioChannelImpl*>(channels[i]);
Harvey Yang34c54d52020-05-20 13:34:20 +0800331 if (!chn->IsEnabled())
332 continue;
333
334 size_t len = chn->Length().value_or(0);
335 if (len == 0)
336 continue;
337 len /= CHAR_BIT;
338
339 size_t space_in_block = sizeof(int64_t) - (pos % sizeof(int64_t));
340 if (len > space_in_block) {
341 pos += space_in_block;
342 }
343
344 base::Optional<int64_t> value = chn->Convert(src + pos);
345 pos += len;
346
347 if (value.has_value())
Harvey Yang9f48d812020-06-30 16:24:30 +0800348 sample[i] = value.value();
Harvey Yang34c54d52020-05-20 13:34:20 +0800349 }
350
Harvey Yang9f48d812020-06-30 16:24:30 +0800351 return sample;
Harvey Yang34c54d52020-05-20 13:34:20 +0800352}
353
Enrico Granata51cdb942019-06-18 16:40:17 -0700354} // namespace libmems