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