peripheralmanager/client/gpio_impl.cc

/*
 * Copyright (C) 2016 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "gpio_impl.h"

#include <android-base/unique_fd.h>
#include <binder/Status.h>

#include "peripheralmanager/constants.h"
#include "peripheralmanager/gpio.h"

using android::binder::Status;
using android::os::IPeripheralManagerClient;
using android::GpioActiveType;
using android::GpioDirection;
using android::GpioEdgeType;

bool ActiveTypeFromInt(int type, GpioActiveType* out) {
  if (type == ACTIVE_LOW) {
    *out = android::kActiveLow;
    return true;
  } else if (type == ACTIVE_HIGH) {
    *out = android::kActiveHigh;
    return true;
  }
  return false;
}

bool DirectionFromInt(int direction, android::GpioDirection* out) {
  switch (direction) {
    case DIRECTION_IN:
      *out = android::kDirectionIn;
      return true;
    case DIRECTION_OUT_INITIALLY_HIGH:
      *out = android::kDirectionOutInitiallyHigh;
      return true;
    case DIRECTION_OUT_INITIALLY_LOW:
      *out = android::kDirectionOutInitiallyLow;
      return true;
  }
  return false;
}

bool EdgeTypeFromInt(int type, android::GpioEdgeType* out) {
  switch (type) {
    case NONE_EDGE:
      *out = android::kEdgeNone;
      return true;
    case RISING_EDGE:
      *out = android::kEdgeRising;
      return true;
    case FALLING_EDGE:
      *out = android::kEdgeFalling;
      return true;
    case BOTH_EDGE:
      *out = android::kEdgeBoth;
      return true;
  }
  return false;
}

GpioImpl::GpioImpl(const std::string name,
                   android::sp<IPeripheralManagerClient> client)
    : name_(name), client_(client) {}

GpioImpl::~GpioImpl() {
  client_->ReleaseGpio(name_);
}

int GpioImpl::SetDirection(GpioDirection direction) {
  return client_->SetGpioDirection(name_, direction).serviceSpecificErrorCode();
}

int GpioImpl::SetEdgeTriggerType(GpioEdgeType type) {
  return client_->SetGpioEdge(name_, type).serviceSpecificErrorCode();
}

int GpioImpl::SetActiveType(GpioActiveType type) {
  return client_->SetGpioActiveType(name_, type).serviceSpecificErrorCode();
}

int GpioImpl::SetValue(int value) {
  return client_->SetGpioValue(name_, value != 0).serviceSpecificErrorCode();
}

int GpioImpl::GetValue(int* value) {
  bool val = true;
  Status ret = client_->GetGpioValue(name_, &val);
  if (ret.isOk()) {
    *value = val ? 1 : 0;
  }
  return ret.serviceSpecificErrorCode();
}

int GpioImpl::GetPollingFd(int* fd) {
  android::base::unique_fd scoped_fd;
  Status ret = client_->GetGpioPollingFd(name_, &scoped_fd);
  if (ret.isOk()) {
    uint8_t buf[2];
    read(scoped_fd.get(), buf, 2);
    lseek(scoped_fd.get(), 0, SEEK_SET);
    *fd = scoped_fd.release();
  }
  return ret.serviceSpecificErrorCode();
}