Merge 261317 "Read and expose accelerometer values from cros-ec-..."

chromeos/accelerometer/accelerometer_reader.cc

+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chromeos/accelerometer/accelerometer_reader.h"
+
+#include "base/bind.h"
+#include "base/file_util.h"
+#include "base/location.h"
+#include "base/message_loop/message_loop.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
+#include "base/task_runner.h"
+#include "base/task_runner_util.h"
+#include "base/threading/sequenced_worker_pool.h"
+
+namespace chromeos {
+
+namespace {
+
+// Paths to access necessary data from the accelerometer device.
+const base::FilePath::CharType kAccelerometerTriggerPath[] =
+    FILE_PATH_LITERAL("/sys/bus/iio/devices/trigger0/trigger_now");
+const base::FilePath::CharType kAccelerometerDevicePath[] =
+    FILE_PATH_LITERAL("/dev/cros-ec-accel");
+const base::FilePath::CharType kAccelerometerIioBasePath[] =
+    FILE_PATH_LITERAL("/sys/bus/iio/devices/");
+
+// Files within the device in kAccelerometerIioBasePath containing the scales of
+// the accelerometers.
+const base::FilePath::CharType kAccelerometerBaseScaleName[] =
+    FILE_PATH_LITERAL("in_accel_base_scale");
+const base::FilePath::CharType kAccelerometerLidScaleName[] =
+    FILE_PATH_LITERAL("in_accel_lid_scale");
+
+// The filename giving the path to read the scan index of each accelerometer
+// axis.
+const char kAccelerometerScanIndexPath[] =
+    "scan_elements/in_accel_%s_%s_index";
+
+// The names of the accelerometers and axes in the order we want to read them.
+const char kAccelerometerNames[][5] = {"base", "lid"};
+const char kAccelerometerAxes[][2] = {"x", "y", "z"};
+const size_t kTriggerDataValues =
+    arraysize(kAccelerometerNames) * arraysize(kAccelerometerAxes);
+const size_t kTriggerDataLength = kTriggerDataValues * 2;
+
+// The length required to read uint values from configuration files.
+const size_t kMaxAsciiUintLength = 21;
+
+// The time to wait between reading the accelerometer.
+const int kDelayBetweenReadsMs = 100;
+
+// Reads |path| to the unsigned int pointed to by |value|. Returns true on
+// success or false on failure.
+bool ReadFileToUint(const base::FilePath& path, unsigned int* value) {
+  std::string s;
+  DCHECK(value);
+  if (!base::ReadFileToString(path, &s, kMaxAsciiUintLength)) {
+    LOG(ERROR) << "Failed to read " << path.value();
+    return false;
+  }
+  base::TrimWhitespaceASCII(s, base::TRIM_ALL, &s);
+  if (!base::StringToUint(s, value)) {
+    LOG(ERROR) << "Failed to parse \"" << s << "\" from " << path.value();
+    return false;
+  }
+  return true;
+}
+
+bool DetectAndReadAccelerometerConfiguration(
+    scoped_refptr<AccelerometerReader::Configuration> configuration) {
+  // Check for accelerometer symlink which will be created by the udev rules
+  // file on detecting the device.
+  base::FilePath device;
+  if (!base::ReadSymbolicLink(base::FilePath(kAccelerometerDevicePath),
+                              &device)) {
+    return false;
+  }
+
+  if (!base::PathExists(base::FilePath(kAccelerometerTriggerPath))) {
+    LOG(ERROR) << "Accelerometer trigger does not exist at"
+               << kAccelerometerTriggerPath;
+    return false;
+  }
+
+  base::FilePath iio_path(base::FilePath(kAccelerometerIioBasePath).Append(
+      device));
+  // Read accelerometer scales
+  if (!ReadFileToUint(iio_path.Append(kAccelerometerBaseScaleName),
+                      &(configuration->data.base_scale))) {
+    return false;
+  }
+  if (!ReadFileToUint(iio_path.Append(kAccelerometerLidScaleName),
+                      &(configuration->data.lid_scale))) {
+    return false;
+  }
+
+  // Read indices of each accelerometer axis from each accelerometer from
+  // /sys/bus/iio/devices/iio:deviceX/scan_elements/in_accel_{x,y,z}_%s_index
+  for (size_t i = 0; i < arraysize(kAccelerometerNames); ++i) {
+    for (size_t j = 0; j < arraysize(kAccelerometerAxes); ++j) {
+      std::string accelerometer_index_path = base::StringPrintf(
+          kAccelerometerScanIndexPath, kAccelerometerAxes[j],
+          kAccelerometerNames[i]);
+      unsigned int index = 0;
+      if (!ReadFileToUint(iio_path.Append(accelerometer_index_path.c_str()),
+                          &index)) {
+        return false;
+      }
+      if (index >= kTriggerDataValues) {
+        LOG(ERROR) << "Field index from " << accelerometer_index_path
+                   << " out of bounds: " << index;
+        return false;
+      }
+      configuration->data.index.push_back(index);
+    }
+  }
+  return true;
+}
+
+bool ReadAccelerometer(
+    scoped_refptr<AccelerometerReader::Reading> reading) {
+  // Initiate the trigger to read accelerometers simultaneously
+  int bytes_written = base::WriteFile(
+      base::FilePath(kAccelerometerTriggerPath), "1\n", 2);
+  if (bytes_written < 2) {
+    PLOG(ERROR) << "Accelerometer trigger failure: " << bytes_written;
+    return false;
+  }
+
+  // Read resulting sample from /dev/cros-ec-accel.
+  int bytes_read = base::ReadFile(base::FilePath(kAccelerometerDevicePath),
+                                  reading->data, kTriggerDataLength);
+  if (bytes_read < static_cast<int>(kTriggerDataLength)) {
+    LOG(ERROR) << "Read " << bytes_read << " byte(s), expected "
+               << kTriggerDataLength << " bytes from accelerometer";
+    return false;
+  }
+  return true;
+}
+
+}  // namespace
+
+AccelerometerReader::ConfigurationData::ConfigurationData() {
+}
+
+AccelerometerReader::ConfigurationData::~ConfigurationData() {
+}
+
+AccelerometerReader::AccelerometerReader(
+    base::TaskRunner* task_runner,
+    AccelerometerReader::Delegate* delegate)
+    : task_runner_(task_runner),
+      delegate_(delegate),
+      configuration_(new AccelerometerReader::Configuration()),
+      weak_factory_(this) {
+  DCHECK(task_runner_);
+  DCHECK(delegate_);
+  // Asynchronously detect and initialize the accelerometer to avoid delaying
+  // startup.
+  base::PostTaskAndReplyWithResult(task_runner_.get(), FROM_HERE,
+      base::Bind(&DetectAndReadAccelerometerConfiguration, configuration_),
+      base::Bind(&AccelerometerReader::OnInitialized,
+                 weak_factory_.GetWeakPtr(), configuration_));
+}
+
+AccelerometerReader::~AccelerometerReader() {
+}
+
+void AccelerometerReader::OnInitialized(
+    scoped_refptr<AccelerometerReader::Configuration> configuration,
+    bool success) {
+  if (success)
+    TriggerRead();
+}
+
+void AccelerometerReader::TriggerRead() {
+  DCHECK(!task_runner_->RunsTasksOnCurrentThread());
+
+  scoped_refptr<AccelerometerReader::Reading> reading(
+      new AccelerometerReader::Reading());
+  base::PostTaskAndReplyWithResult(task_runner_, FROM_HERE,
+      base::Bind(&ReadAccelerometer, reading),
+      base::Bind(&AccelerometerReader::OnDataRead,
+          weak_factory_.GetWeakPtr(), reading));
+}
+
+void AccelerometerReader::OnDataRead(
+    scoped_refptr<AccelerometerReader::Reading> reading,
+    bool success) {
+  DCHECK(!task_runner_->RunsTasksOnCurrentThread());
+
+  if (success) {
+    gfx::Vector3dF base_reading, lid_reading;
+    int16* values = reinterpret_cast<int16*>(reading->data);
+    base_reading.set_x(values[configuration_->data.index[0]]);
+    base_reading.set_y(values[configuration_->data.index[1]]);
+    base_reading.set_z(values[configuration_->data.index[2]]);
+    base_reading.Scale(1.0f / configuration_->data.base_scale);
+
+    lid_reading.set_x(values[configuration_->data.index[3]]);
+    lid_reading.set_y(values[configuration_->data.index[4]]);
+    lid_reading.set_z(values[configuration_->data.index[5]]);
+    lid_reading.Scale(1.0f / configuration_->data.lid_scale);
+    delegate_->HandleAccelerometerReading(base_reading, lid_reading);
+  }
+
+  // Trigger another read after the current sampling delay.
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&AccelerometerReader::TriggerRead,
+                 weak_factory_.GetWeakPtr()),
+      base::TimeDelta::FromMilliseconds(kDelayBetweenReadsMs));
+}
+
+}  // namespace chromeos