Export the UART functionality via binder.

Allows the binder clients to access UART devices.

Bug: 27898961

Change-Id: Ifa94a2864c0bad8a3fb38948b4dac57c876d5290

3 files changed, 110 insertions, 0 deletions

diff --git a/daemon/peripheral_manager_client.cc b/daemon/peripheral_manager_client.cc
index bd05537..8dc30ea 100644
--- a/daemon/peripheral_manager_client.cc
+++ b/daemon/peripheral_manager_client.cc
@@ -487,4 +487,80 @@ Status PeripheralManagerClient::I2cWriteRegBuffer(
   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
diff --git a/daemon/peripheral_manager_client.h b/daemon/peripheral_manager_client.h
index 4db211d..bdba9ef 100644
--- a/daemon/peripheral_manager_client.h
+++ b/daemon/peripheral_manager_client.h
@@ -29,6 +29,7 @@
 #include "i2c_manager.h"
 #include "led_manager.h"
 #include "spi_manager.h"
+#include "uart_manager.h"
 
 using android::binder::Status;
 using android::os::BnPeripheralManagerClient;
@@ -162,12 +163,32 @@ class PeripheralManagerClient : public BnPeripheralManagerClient {
                                    const std::vector<uint8_t>& data,
                                    int32_t* bytes_written) override;
 
+  // Uart functions.
+  virtual Status ListUartDevices(std::vector<std::string>* devices) override;
+
+  virtual Status OpenUartDevice(const std::string& name) override;
+
+  virtual Status ReleaseUartDevice(const std::string& name) override;
+
+  virtual Status SetUartDeviceBaudrate(const std::string& name,
+                                       int32_t baudrate) override;
+
+  virtual Status UartDeviceWrite(const std::string& name,
+                                 const std::vector<uint8_t>& data,
+                                 int* bytes_written) override;
+
+  virtual Status UartDeviceRead(const std::string& name,
+                                std::vector<uint8_t>* data,
+                                int size,
+                                int* bytes_read) override;
+
  private:
   std::map<std::string, std::unique_ptr<GpioPin>> gpios_;
   std::map<std::pair<std::string, uint32_t>, std::unique_ptr<I2cDevice>>
       i2c_devices_;
   std::map<std::string, std::unique_ptr<SpiDevice>> spi_devices_;
   std::map<std::string, std::unique_ptr<Led>> leds_;
+  std::map<std::string, std::unique_ptr<UartDevice>> uart_devices_;
   DISALLOW_COPY_AND_ASSIGN(PeripheralManagerClient);
 };
 
diff --git a/ipc/android/os/IPeripheralManagerClient.aidl b/ipc/android/os/IPeripheralManagerClient.aidl
index 61a0e5a..98e1196 100644
--- a/ipc/android/os/IPeripheralManagerClient.aidl
+++ b/ipc/android/os/IPeripheralManagerClient.aidl
@@ -101,4 +101,17 @@ interface IPeripheralManagerClient {
 
   int I2cWriteRegBuffer(@utf8InCpp String name, int address, int reg,
                         in byte[] data);
+
+  // Uart functions
+  void ListUartDevices(out @utf8InCpp List<String> devices);
+
+  void OpenUartDevice(@utf8InCpp String name);
+
+  void ReleaseUartDevice(@utf8InCpp String name);
+
+  void SetUartDeviceBaudrate(@utf8InCpp String name, int baudrate);
+
+  int UartDeviceWrite(@utf8InCpp String name, in byte[] data);
+
+  int UartDeviceRead(@utf8InCpp String name, out byte[] data, int size);
 }