| /* |
| * 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 "peripheral_manager_client.h" |
| |
| #include <base/logging.h> |
| |
| namespace android { |
| |
| PeripheralManagerClient::PeripheralManagerClient() {} |
| PeripheralManagerClient::~PeripheralManagerClient() {} |
| |
| Status PeripheralManagerClient::ListGpio(std::vector<std::string>* gpios) { |
| *gpios = GpioManager::GetGpioManager()->GetGpioPins(); |
| return Status::ok(); |
| } |
| |
| Status PeripheralManagerClient::OpenGpio(const std::string& name) { |
| if (!GpioManager::GetGpioManager()->HasGpio(name)) |
| return Status::fromServiceSpecificError(ENODEV); |
| |
| auto gpio = GpioManager::GetGpioManager()->OpenGpioPin(name); |
| if (!gpio) { |
| LOG(ERROR) << "Failed to open GPIO " << name; |
| return Status::fromServiceSpecificError(EBUSY); |
| } |
| |
| gpios_.emplace(name, std::move(gpio)); |
| return Status::ok(); |
| } |
| |
| Status PeripheralManagerClient::ReleaseGpio(const std::string& name) { |
| gpios_.erase(name); |
| return Status::ok(); |
| } |
| |
| Status PeripheralManagerClient::SetGpioEdge(const std::string& name, int type) { |
| if (!gpios_.count(name)) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| if (gpios_.find(name)->second->SetEdgeType(GpioEdgeType(type))) |
| return Status::ok(); |
| |
| return Status::fromServiceSpecificError(EREMOTEIO); |
| } |
| |
| Status PeripheralManagerClient::SetGpioActiveType(const std::string& name, |
| int type) { |
| if (!gpios_.count(name)) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| if (gpios_.find(name)->second->SetActiveType(GpioActiveType(type))) |
| return Status::ok(); |
| |
| return Status::fromServiceSpecificError(EREMOTEIO); |
| } |
| |
| Status PeripheralManagerClient::SetGpioDirection(const std::string& name, |
| int direction) { |
| if (!gpios_.count(name)) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| if (gpios_.find(name)->second->SetDirection(GpioDirection(direction))) |
| return Status::ok(); |
| |
| return Status::fromServiceSpecificError(EREMOTEIO); |
| } |
| |
| Status PeripheralManagerClient::SetGpioValue(const std::string& name, |
| bool value) { |
| if (!gpios_.count(name)) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| if (gpios_.find(name)->second->SetValue(value)) |
| return Status::ok(); |
| |
| return Status::fromServiceSpecificError(EREMOTEIO); |
| } |
| |
| Status PeripheralManagerClient::GetGpioValue(const std::string& name, |
| bool* value) { |
| if (!gpios_.count(name)) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| if (gpios_.find(name)->second->GetValue(value)) |
| return Status::ok(); |
| |
| return Status::fromServiceSpecificError(EREMOTEIO); |
| } |
| |
| Status PeripheralManagerClient::GetGpioPollingFd( |
| const std::string& name, |
| ::android::base::unique_fd* fd) { |
| if (!gpios_.count(name)) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| if (gpios_.find(name)->second->GetPollingFd(fd)) |
| return Status::ok(); |
| |
| return Status::fromServiceSpecificError(EREMOTEIO); |
| } |
| |
| Status PeripheralManagerClient::ListSpiBuses(std::vector<std::string>* buses) { |
| *buses = SpiManager::GetSpiManager()->GetSpiDevBuses(); |
| return Status::ok(); |
| } |
| |
| Status PeripheralManagerClient::OpenSpiDevice(const std::string& name) { |
| if (!SpiManager::GetSpiManager()->HasSpiDevBus(name)) |
| return Status::fromServiceSpecificError(ENODEV); |
| |
| std::unique_ptr<SpiDevice> device = |
| SpiManager::GetSpiManager()->OpenSpiDevice(name); |
| |
| if (!device) { |
| LOG(ERROR) << "Failed to open device " << name; |
| return Status::fromServiceSpecificError(EBUSY); |
| } |
| |
| spi_devices_.emplace(name, std::move(device)); |
| return Status::ok(); |
| } |
| |
| Status PeripheralManagerClient::ReleaseSpiDevice(const std::string& name) { |
| if (!spi_devices_.count(name)) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| spi_devices_.erase(name); |
| return Status::ok(); |
| } |
| |
| Status PeripheralManagerClient::SpiDeviceWriteByte(const std::string& name, |
| int8_t byte) { |
| if (!spi_devices_.count(name)) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| if (spi_devices_.find(name)->second->WriteByte(byte)) |
| return Status::ok(); |
| |
| return Status::fromServiceSpecificError(EREMOTEIO); |
| } |
| |
| Status PeripheralManagerClient::SpiDeviceWriteBuffer( |
| const std::string& name, |
| const std::vector<uint8_t>& buffer) { |
| if (!spi_devices_.count(name)) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| if (spi_devices_.find(name)->second->WriteBuffer(buffer.data(), |
| buffer.size())) |
| return Status::ok(); |
| |
| return Status::fromServiceSpecificError(EREMOTEIO); |
| } |
| |
| Status PeripheralManagerClient::SpiDeviceTransfer( |
| const std::string& name, |
| const std::unique_ptr<std::vector<uint8_t>>& tx_data, |
| std::unique_ptr<std::vector<uint8_t>>* rx_data, |
| int size) { |
| if (!spi_devices_.count(name)) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| if (!rx_data) { |
| if (spi_devices_.find(name)->second->Transfer(tx_data->data(), nullptr, |
| size)) { |
| return Status::ok(); |
| } |
| } else { |
| rx_data->reset(new std::vector<uint8_t>(size)); |
| if (spi_devices_.find(name)->second->Transfer(tx_data->data(), |
| (*rx_data)->data(), size)) { |
| return Status::ok(); |
| } |
| } |
| |
| return Status::fromServiceSpecificError(EREMOTEIO); |
| } |
| |
| Status PeripheralManagerClient::SpiDeviceSetMode(const std::string& name, |
| int mode) { |
| if (!spi_devices_.count(name)) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| if (spi_devices_.find(name)->second->SetMode(SpiMode(mode))) |
| return Status::ok(); |
| |
| return Status::fromServiceSpecificError(EREMOTEIO); |
| } |
| |
| Status PeripheralManagerClient::SpiDeviceSetFrequency(const std::string& name, |
| int frequency_hz) { |
| if (!spi_devices_.count(name)) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| if (frequency_hz > 0 && |
| spi_devices_.find(name)->second->SetFrequency(frequency_hz)) |
| return Status::ok(); |
| |
| return Status::fromServiceSpecificError(EREMOTEIO); |
| } |
| |
| Status PeripheralManagerClient::SpiDeviceSetBitJustification( |
| const std::string& name, |
| bool lsb_first) { |
| if (!spi_devices_.count(name)) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| if (spi_devices_.find(name)->second->SetBitJustification(lsb_first)) |
| return Status::ok(); |
| |
| return Status::fromServiceSpecificError(EREMOTEIO); |
| } |
| |
| Status PeripheralManagerClient::SpiDeviceSetBitsPerWord(const std::string& name, |
| int nbits) { |
| if (!spi_devices_.count(name)) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| if (spi_devices_.find(name)->second->SetBitsPerWord(nbits)) |
| return Status::ok(); |
| |
| return Status::fromServiceSpecificError(EREMOTEIO); |
| } |
| |
| Status PeripheralManagerClient::SpiDeviceSetDelay(const std::string& name, |
| int delay_usecs) { |
| if (!spi_devices_.count(name)) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| // |delay_usecs| must be positive and fit in an unsigned 16 bit. |
| if (delay_usecs < 0 || delay_usecs > INT16_MAX) |
| return Status::fromServiceSpecificError(EINVAL); |
| |
| if (spi_devices_.find(name)->second->SetDelay( |
| static_cast<uint16_t>(delay_usecs))) |
| return Status::ok(); |
| |
| return Status::fromServiceSpecificError(EREMOTEIO); |
| } |
| |
| Status PeripheralManagerClient::ListLeds(std::vector<std::string>* leds) { |
| *leds = LedManager::GetLedManager()->GetLeds(); |
| return Status::ok(); |
| } |
| |
| Status PeripheralManagerClient::OpenLed(const std::string& name) { |
| if (!LedManager::GetLedManager()->HasLed(name)) { |
| return Status::fromServiceSpecificError(ENODEV); |
| } |
| auto led = LedManager::GetLedManager()->OpenLed(name); |
| if (!led) { |
| LOG(ERROR) << "Failed to open LED " << name; |
| return Status::fromServiceSpecificError(EBUSY); |
| } |
| |
| leds_.emplace(name, std::move(led)); |
| return Status::ok(); |
| } |
| |
| Status PeripheralManagerClient::ReleaseLed(const std::string& name) { |
| leds_.erase(name); |
| return Status::ok(); |
| } |
| |
| Status PeripheralManagerClient::LedGetBrightness(const std::string& name, |
| int* brightness) { |
| if (!leds_.count(name)) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| uint32_t temp; |
| if (leds_.find(name)->second->GetBrightness(&temp)) { |
| *brightness = temp; |
| return Status::ok(); |
| } |
| |
| return Status::fromServiceSpecificError(EREMOTEIO); |
| } |
| |
| Status PeripheralManagerClient::LedGetMaxBrightness(const std::string& name, |
| int* max_brightness) { |
| if (!leds_.count(name)) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| uint32_t temp; |
| if (leds_.find(name)->second->GetMaxBrightness(&temp)) { |
| *max_brightness = temp; |
| return Status::ok(); |
| } |
| |
| return Status::fromServiceSpecificError(EREMOTEIO); |
| } |
| |
| Status PeripheralManagerClient::LedSetBrightness(const std::string& name, |
| int brightness) { |
| if (!leds_.count(name)) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| if (leds_.find(name)->second->SetBrightness(brightness)) |
| return Status::ok(); |
| |
| return Status::fromServiceSpecificError(EREMOTEIO); |
| } |
| |
| Status PeripheralManagerClient::ListI2cBuses(std::vector<std::string>* buses) { |
| *buses = I2cManager::GetI2cManager()->GetI2cDevBuses(); |
| |
| return Status::ok(); |
| } |
| |
| Status PeripheralManagerClient::OpenI2cDevice(const std::string& name, |
| int32_t address) { |
| if (!I2cManager::GetI2cManager()->HasI2cDevBus(name)) |
| return Status::fromServiceSpecificError(ENODEV); |
| |
| std::unique_ptr<I2cDevice> device = |
| I2cManager::GetI2cManager()->OpenI2cDevice(name, address); |
| |
| if (!device) { |
| LOG(ERROR) << "Failed to open device " << name; |
| return Status::fromServiceSpecificError(EBUSY); |
| } |
| std::pair<std::string, uint32_t> i2c_dev(name, address); |
| i2c_devices_.emplace(i2c_dev, std::move(device)); |
| return Status::ok(); |
| } |
| |
| Status PeripheralManagerClient::ReleaseI2cDevice(const std::string& name, |
| int32_t address) { |
| if (!i2c_devices_.count({name, address})) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| i2c_devices_.erase({name, address}); |
| return Status::ok(); |
| } |
| |
| Status PeripheralManagerClient::I2cRead(const std::string& name, |
| int32_t address, |
| std::vector<uint8_t>* data, |
| int32_t size, |
| int32_t* bytes_read) { |
| if (!i2c_devices_.count({name, address})) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| if (size < 0) { |
| return Status::fromServiceSpecificError(EINVAL); |
| } |
| data->resize(size); |
| |
| uint32_t* nread = reinterpret_cast<uint32_t*>(bytes_read); |
| int32_t ret = i2c_devices_.find({name, address}) |
| ->second->Read(data->data(), data->size(), nread); |
| data->resize(*nread); |
| |
| return ret == 0 ? Status::ok() : Status::fromServiceSpecificError(ret); |
| } |
| |
| Status PeripheralManagerClient::I2cReadRegByte(const std::string& name, |
| int32_t address, |
| int32_t reg, |
| int32_t* val) { |
| if (!i2c_devices_.count({name, address})) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| uint8_t tmp_val = 0; |
| if (i2c_devices_.find({name, address})->second->ReadRegByte(reg, &tmp_val) == |
| 0) { |
| *val = tmp_val; |
| return Status::ok(); |
| } |
| |
| return Status::fromServiceSpecificError(EREMOTEIO); |
| } |
| |
| Status PeripheralManagerClient::I2cReadRegWord(const std::string& name, |
| int32_t address, |
| int32_t reg, |
| int32_t* val) { |
| if (!i2c_devices_.count({name, address})) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| uint16_t tmp_val = 0; |
| if (i2c_devices_.find({name, address})->second->ReadRegWord(reg, &tmp_val) == |
| 0) { |
| *val = tmp_val; |
| return Status::ok(); |
| } |
| |
| return Status::fromServiceSpecificError(EREMOTEIO); |
| } |
| |
| Status PeripheralManagerClient::I2cReadRegBuffer(const std::string& name, |
| int32_t address, |
| int32_t reg, |
| std::vector<uint8_t>* data, |
| int32_t size, |
| int32_t* bytes_read) { |
| if (!i2c_devices_.count({name, address})) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| if (size < 0) { |
| return Status::fromServiceSpecificError(EINVAL); |
| } |
| data->resize(size); |
| |
| uint32_t* nread = reinterpret_cast<uint32_t*>(bytes_read); |
| int32_t ret = |
| i2c_devices_.find({name, address}) |
| ->second->ReadRegBuffer(reg, data->data(), data->size(), nread); |
| |
| data->resize(*nread); |
| return ret == 0 ? Status::ok() : Status::fromServiceSpecificError(ret); |
| } |
| |
| Status PeripheralManagerClient::I2cWrite(const std::string& name, |
| int32_t address, |
| const std::vector<uint8_t>& data, |
| int32_t* bytes_written) { |
| if (!i2c_devices_.count({name, address})) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| int ret = i2c_devices_.find({name, address}) |
| ->second->Write(data.data(), |
| data.size(), |
| reinterpret_cast<uint32_t*>(bytes_written)); |
| |
| return ret == 0 ? Status::ok() : Status::fromServiceSpecificError(ret); |
| } |
| |
| Status PeripheralManagerClient::I2cWriteRegByte(const std::string& name, |
| int32_t address, |
| int32_t reg, |
| int8_t val) { |
| if (!i2c_devices_.count({name, address})) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| if (i2c_devices_.find({name, address})->second->WriteRegByte(reg, val) == 0) { |
| return Status::ok(); |
| } |
| |
| return Status::fromServiceSpecificError(EREMOTEIO); |
| } |
| |
| Status PeripheralManagerClient::I2cWriteRegWord(const std::string& name, |
| int32_t address, |
| int32_t reg, |
| int32_t val) { |
| if (!i2c_devices_.count({name, address})) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| if (i2c_devices_.find({name, address})->second->WriteRegWord(reg, val) == 0) { |
| return Status::ok(); |
| } |
| |
| return Status::fromServiceSpecificError(EREMOTEIO); |
| } |
| |
| Status PeripheralManagerClient::I2cWriteRegBuffer( |
| const std::string& name, |
| int32_t address, |
| int32_t reg, |
| const std::vector<uint8_t>& data, |
| int32_t* bytes_written) { |
| if (!i2c_devices_.count({name, address})) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| int32_t ret = |
| i2c_devices_.find({name, address}) |
| ->second->WriteRegBuffer(reg, |
| data.data(), |
| data.size(), |
| reinterpret_cast<uint32_t*>(bytes_written)); |
| |
| return ret == 0 ? Status::ok() : Status::fromServiceSpecificError(ret); |
| } |
| |
| Status PeripheralManagerClient::ListUartDevices( |
| std::vector<std::string>* devices) { |
| *devices = UartManager::GetManager()->GetDevicesList(); |
| return Status::ok(); |
| } |
| |
| Status PeripheralManagerClient::OpenUartDevice(const std::string& name) { |
| if (!UartManager::GetManager()->HasUartDevice(name)) |
| return Status::fromServiceSpecificError(ENODEV); |
| |
| auto uart_device = UartManager::GetManager()->OpenUartDevice(name); |
| if (!uart_device) { |
| LOG(ERROR) << "Failed to open UART device " << name; |
| return Status::fromServiceSpecificError(EBUSY); |
| } |
| |
| uart_devices_.emplace(name, std::move(uart_device)); |
| return Status::ok(); |
| } |
| |
| Status PeripheralManagerClient::ReleaseUartDevice(const std::string& name) { |
| return uart_devices_.erase(name) ? Status::ok() |
| : Status::fromServiceSpecificError(EPERM); |
| } |
| |
| Status PeripheralManagerClient::SetUartDeviceBaudrate(const std::string& name, |
| int32_t baudrate) { |
| auto uart_device = uart_devices_.find(name); |
| if (uart_device == uart_devices_.end()) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| if (baudrate < 0) |
| return Status::fromServiceSpecificError(EINVAL); |
| |
| int ret = uart_device->second->SetBaudrate(static_cast<uint32_t>(baudrate)); |
| |
| if (ret) |
| return Status::fromServiceSpecificError(ret); |
| |
| return Status::ok(); |
| } |
| |
| Status PeripheralManagerClient::UartDeviceWrite( |
| const std::string& name, |
| const std::vector<uint8_t>& data, |
| int32_t* bytes_written) { |
| auto uart_device = uart_devices_.find(name); |
| if (uart_device == uart_devices_.end()) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| int ret = uart_device->second->Write( |
| data, reinterpret_cast<uint32_t*>(bytes_written)); |
| |
| if (ret) |
| return Status::fromServiceSpecificError(ret); |
| |
| return Status::ok(); |
| } |
| |
| Status PeripheralManagerClient::UartDeviceRead(const std::string& name, |
| std::vector<uint8_t>* data, |
| int size, |
| int* bytes_read) { |
| auto uart_device = uart_devices_.find(name); |
| if (uart_device == uart_devices_.end()) |
| return Status::fromServiceSpecificError(EPERM); |
| |
| int ret = uart_device->second->Read( |
| data, size, reinterpret_cast<uint32_t*>(bytes_read)); |
| |
| if (ret) |
| return Status::fromServiceSpecificError(ret); |
| |
| return Status::ok(); |
| } |
| |
| } // namespace android |
