Wire up GPIO and SPI list commands

Fixed bug in SPI transfer

Change-Id: I384a94e330a9962902044652a1d3cd5ae016ce0d

11 files changed, 104 insertions, 20 deletions

diff --git a/client/peripheral_manager_client_impl.cc b/client/peripheral_manager_client_impl.cc
index 2d392e2..7ee67ff 100644
--- a/client/peripheral_manager_client_impl.cc
+++ b/client/peripheral_manager_client_impl.cc
@@ -40,11 +40,22 @@ int PeripheralManagerClientImpl::OpenGpio(const std::string& name,
   return status.serviceSpecificErrorCode();
 }
 
+int PeripheralManagerClientImpl::ListGpio(std::vector<std::string>* gpios) {
+  Status status = client_->ListGpio(gpios);
+  return status.serviceSpecificErrorCode();
+}
+
 int PeripheralManagerClientImpl::OpenSpiDevice(
-    const std::string& name, std::unique_ptr<SpiDeviceImpl>* device) {
+    const std::string& name,
+    std::unique_ptr<SpiDeviceImpl>* device) {
   Status status = client_->OpenSpiDevice(name);
   if (status.serviceSpecificErrorCode() == PERIPHERAL_IO_OK) {
     device->reset(new SpiDeviceImpl(name, client_));
   }
   return status.serviceSpecificErrorCode();
 }
+
+int PeripheralManagerClientImpl::ListSpiBuses(std::vector<std::string>* buses) {
+  Status status = client_->ListSpiBuses(buses);
+  return status.serviceSpecificErrorCode();
+}
diff --git a/client/peripheral_manager_client_impl.h b/client/peripheral_manager_client_impl.h
index eb88160..3a3000d 100644
--- a/client/peripheral_manager_client_impl.h
+++ b/client/peripheral_manager_client_impl.h
@@ -30,9 +30,11 @@ class PeripheralManagerClientImpl {
   bool Init();
 
   int OpenGpio(const std::string& name, std::unique_ptr<GpioImpl>* gpio);
+  int ListGpio(std::vector<std::string>* gpios);
 
   int OpenSpiDevice(const std::string& name,
                     std::unique_ptr<SpiDeviceImpl>* device);
+  int ListSpiBuses(std::vector<std::string>* buses);
 
  private:
   android::sp<android::os::IPeripheralManagerClient> client_;
diff --git a/client/wrapper.cc b/client/wrapper.cc
index 1ac11d4..77f45ce 100644
--- a/client/wrapper.cc
+++ b/client/wrapper.cc
@@ -21,6 +21,21 @@
 #include "peripheral_manager_client_impl.h"
 #include "peripheralmanager/peripheral_manager_client.h"
 
+namespace {
+
+// This is horrible. Get rid of it!!!
+static char** ConvertStringVectorToC(const std::vector<std::string>& strings) {
+  char** c_strings = (char**)malloc(strings.size() * sizeof(*c_strings));
+  for (size_t i = 0; i < strings.size(); i++) {
+    c_strings[i] = (char*)malloc(strings[i].size() + 1);
+    memset(c_strings[i], 0, strings[i].size() + 1);
+    strcpy(c_strings[i], strings[i].c_str());
+  }
+  return c_strings;
+}
+
+}  // namespace
+
 struct BPeripheralManagerClient {
   PeripheralManagerClientImpl* impl;
 };
@@ -48,6 +63,14 @@ void BPeripheralManagerClient_delete(BPeripheralManagerClient* client) {
   delete client;
 }
 
+char** BPeripheralManagerClient_listGpio(const BPeripheralManagerClient* client,
+                                         int* num_gpio) {
+  std::vector<std::string> gpios;
+  client->impl->ListGpio(&gpios);
+  *num_gpio = gpios.size();
+  return ConvertStringVectorToC(gpios);
+}
+
 int BPeripheralManagerClient_openGpio(const BPeripheralManagerClient* client,
                                       const char* name,
                                       BGpio** gpio) {
@@ -100,15 +123,25 @@ void BGpio_delete(BGpio* gpio) {
   delete gpio;
 }
 
+char** BPeripheralManagerClient_listSpiBuses(
+    const BPeripheralManagerClient* client,
+    int* num_spi_buses) {
+  std::vector<std::string> list;
+  client->impl->ListSpiBuses(&list);
+  *num_spi_buses = list.size();
+  return ConvertStringVectorToC(list);
+}
+
 int BPeripheralManagerClient_openSpiDevice(
     const BPeripheralManagerClient* client,
     const char* name,
     BSpiDevice** dev) {
   std::unique_ptr<SpiDeviceImpl> impl;
-  client->impl->OpenSpiDevice(name, &impl);
-
-  *dev = new BSpiDevice{impl.release()};
-  return 0;
+  int ret = client->impl->OpenSpiDevice(name, &impl);
+  if (impl) {
+    *dev = new BSpiDevice{impl.release()};
+  }
+  return ret;
 }
 
 int BSpiDevice_writeByte(const BSpiDevice* device, uint8_t val) {
@@ -126,8 +159,7 @@ int BSpiDevice_transfer(const BSpiDevice* device,
                         void* rx_data,
                         size_t len) {
   return device->impl->Transfer(static_cast<const uint8_t*>(tx_data),
-                                static_cast<uint8_t*>(rx_data),
-                                len);
+                                static_cast<uint8_t*>(rx_data), len);
 }
 
 int BSpiDevice_setFrequency(const BSpiDevice* device, uint32_t freq_hz) {
@@ -143,8 +175,7 @@ int BSpiDevice_setBitJustification(const BSpiDevice* device,
   return device->impl->SetBitJustification(bit_justification);
 }
 
-int BSpiDevice_setBitsPerWord(const BSpiDevice* device,
-                              uint8_t bits_per_word) {
+int BSpiDevice_setBitsPerWord(const BSpiDevice* device, uint8_t bits_per_word) {
   return device->impl->SetBitsPerWord(bits_per_word);
 }
 
diff --git a/daemon/gpio_driver_sysfs.cc b/daemon/gpio_driver_sysfs.cc
index 862b0d7..683cb94 100644
--- a/daemon/gpio_driver_sysfs.cc
+++ b/daemon/gpio_driver_sysfs.cc
@@ -98,6 +98,11 @@ bool GpioDriverSysfs::GetValue(bool* val) {
   std::string read_val;
   if (!ReadFromFile(kValue, &read_val))
     return false;
+  if (read_val.size() < 1) {
+    return false;
+  }
+  // Remove any whitespace.
+  read_val = read_val[0];
   if (read_val == kValueHigh)
     *val = true;
   else
diff --git a/daemon/peripheral_manager_client.cc b/daemon/peripheral_manager_client.cc
index b95e7a0..41ec50c 100644
--- a/daemon/peripheral_manager_client.cc
+++ b/daemon/peripheral_manager_client.cc
@@ -24,6 +24,11 @@ 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) {
   auto gpio = GpioManager::GetGpioManager()->OpenGpioPin(name);
   if (!gpio) {
@@ -95,6 +100,11 @@ Status PeripheralManagerClient::GetGpioPollingFd(const std::string& name,
   return Status::fromServiceSpecificError(PERIPHERAL_IO_UNKNOWN_ERROR);
 }
 
+Status PeripheralManagerClient::ListSpiBuses(std::vector<std::string>* buses) {
+  *buses = SpiManager::GetSpiManager()->GetSpiDevBuses();
+  return Status::ok();
+}
+
 Status PeripheralManagerClient::OpenSpiDevice(const std::string& name) {
   std::unique_ptr<SpiDevice> device =
       SpiManager::GetSpiManager()->OpenSpiDevice(name);
@@ -128,7 +138,8 @@ Status PeripheralManagerClient::SpiDeviceWriteByte(const std::string& name,
 }
 
 Status PeripheralManagerClient::SpiDeviceWriteBuffer(
-    const std::string& name, const std::vector<uint8_t>& buffer) {
+    const std::string& name,
+    const std::vector<uint8_t>& buffer) {
   if (!spi_devices_.count(name))
     return Status::fromServiceSpecificError(PERIPHERAL_IO_UNKNOWN_DEVICE);
 
@@ -153,9 +164,9 @@ Status PeripheralManagerClient::SpiDeviceTransfer(
       return Status::ok();
     }
   } else {
-    uint8_t rx_bytes[size];
-    if (spi_devices_.find(name)->second->Transfer(data_sent, &rx_bytes, size)) {
-      rx_data->get()->assign(rx_bytes, rx_bytes + size);
+    rx_data->reset(new std::vector<uint8_t>(size));
+    if (spi_devices_.find(name)->second->Transfer(data_sent, (*rx_data)->data(),
+                                                  size)) {
       return Status::ok();
     }
   }
@@ -187,7 +198,8 @@ Status PeripheralManagerClient::SpiDeviceSetFrequency(const std::string& name,
 }
 
 Status PeripheralManagerClient::SpiDeviceSetBitJustification(
-    const std::string& name, bool lsb_first) {
+    const std::string& name,
+    bool lsb_first) {
   if (!spi_devices_.count(name))
     return Status::fromServiceSpecificError(PERIPHERAL_IO_UNKNOWN_DEVICE);
 
diff --git a/daemon/peripheral_manager_client.h b/daemon/peripheral_manager_client.h
index b301805..4d57ba6 100644
--- a/daemon/peripheral_manager_client.h
+++ b/daemon/peripheral_manager_client.h
@@ -39,6 +39,9 @@ class PeripheralManagerClient : public BnPeripheralManagerClient {
   ~PeripheralManagerClient();
 
   // Binder functions.
+
+  virtual Status ListGpio(std::vector<std::string>* gpios) override;
+
   virtual Status OpenGpio(const std::string& name) override;
 
   virtual Status ReleaseGpio(const std::string& name) override;
@@ -57,6 +60,8 @@ class PeripheralManagerClient : public BnPeripheralManagerClient {
   virtual Status GetGpioPollingFd(const std::string& name,
                                   ScopedFd* fd) override;
 
+  virtual Status ListSpiBuses(std::vector<std::string>* buses) override;
+
   virtual Status OpenSpiDevice(const std::string& name) override;
 
   virtual Status ReleaseSpiDevice(const std::string& name) override;
@@ -65,7 +70,8 @@ class PeripheralManagerClient : public BnPeripheralManagerClient {
                                     int8_t byte) override;
 
   virtual Status SpiDeviceWriteBuffer(
-      const std::string& name, const std::vector<uint8_t>& buffer) override;
+      const std::string& name,
+      const std::vector<uint8_t>& buffer) override;
 
   virtual Status SpiDeviceTransfer(
       const std::string& name,
diff --git a/daemon/spi_manager.cc b/daemon/spi_manager.cc
index 3afb45c..e4df656 100644
--- a/daemon/spi_manager.cc
+++ b/daemon/spi_manager.cc
@@ -43,7 +43,7 @@ bool SpiManager::RegisterSpiDevBus(const std::string& name,
   return true;
 }
 
-std::vector<std::string> SpiManager::GetSpiDevBusses() {
+std::vector<std::string> SpiManager::GetSpiDevBuses() {
   std::vector<std::string> buses;
   for (auto& i : spidev_buses_)
     buses.push_back(i.first);
diff --git a/daemon/spi_manager.h b/daemon/spi_manager.h
index 92fc9ac..0aeb16d 100644
--- a/daemon/spi_manager.h
+++ b/daemon/spi_manager.h
@@ -92,7 +92,7 @@ class SpiManager {
   // that can be used by a PMan client.
   // Will return false if the bus has already been registered.
   bool RegisterSpiDevBus(const std::string& name, uint32_t bus, uint32_t cs);
-  std::vector<std::string> GetSpiDevBusses();
+  std::vector<std::string> GetSpiDevBuses();
 
   bool SetPinMux(const std::string& name, const std::string& mux);
   bool SetPinMuxWithGroup(const std::string& name,
diff --git a/daemon/spi_manager_unittest.cc b/daemon/spi_manager_unittest.cc
index 51da825..3dacbe5 100644
--- a/daemon/spi_manager_unittest.cc
+++ b/daemon/spi_manager_unittest.cc
@@ -50,7 +50,7 @@ class SpiManagerTest : public ::testing::Test {
 
 TEST_F(SpiManagerTest, SimpleRegister) {
   manager.RegisterSpiDevBus("SPI0_1", 0, 1);
-  std::vector<std::string> busses = manager.GetSpiDevBusses();
+  std::vector<std::string> busses = manager.GetSpiDevBuses();
   ASSERT_EQ(1U, busses.size());
   ASSERT_EQ("SPI0_1", busses[0]);
 }
diff --git a/include/peripheralmanager/peripheral_manager_client.h b/include/peripheralmanager/peripheral_manager_client.h
index 536bfde..bdfce86 100644
--- a/include/peripheralmanager/peripheral_manager_client.h
+++ b/include/peripheralmanager/peripheral_manager_client.h
@@ -46,7 +46,8 @@ char** BPeripheralManagerClient_listGpio(const BPeripheralManagerClient* client,
 /// @param num_gpio Output pointer to the number of element in the list.
 /// @return The list of buses.
 char** BPeripheralManagerClient_listAvailableGpio(
-    const BPeripheralManagerClient* client, int* num_gpio);
+    const BPeripheralManagerClient* client,
+    int* num_gpio);
 
 /// Opens a GPIO and takes ownership of it.
 /// @param client Pointer to the BPeripheralManagerClient struct.
@@ -57,13 +58,25 @@ int BPeripheralManagerClient_openGpio(const BPeripheralManagerClient* client,
                                       const char* name,
                                       BGpio** gpio);
 
+/// Returns the list of SPI buses.
+/// This does not take ownership into account.
+/// The list must be freed by the caller.
+/// @param client Pointer to the BPeripheralManagerClient struct.
+/// @param num_spi_buses Output pointer to the number of element in the list.
+/// @return The list of spi buses.
+char** BPeripheralManagerClient_listSpiBuses(
+    const BPeripheralManagerClient* client,
+    int* num_spi_buses);
+
 /// Opens a SPI device and takes ownership of it.
 /// @oaram client Pointer to the BPeripheralManagerClient struct.
 /// @param name Name of the SPI device.
 /// @param dev Output pointer to the BSpiDevice struct. Empty on error.
 /// @return Error code (one of peripheral_error_t).
 int BPeripheralManagerClient_openSpiDevice(
-    const BPeripheralManagerClient* client, const char* name, BSpiDevice** dev);
+    const BPeripheralManagerClient* client,
+    const char* name,
+    BSpiDevice** dev);
 
 /// Creates a new client.
 /// @return A pointer to the created client. nullptr on errors.
diff --git a/ipc/android/os/IPeripheralManagerClient.aidl b/ipc/android/os/IPeripheralManagerClient.aidl
index ee5e240..60aca42 100644
--- a/ipc/android/os/IPeripheralManagerClient.aidl
+++ b/ipc/android/os/IPeripheralManagerClient.aidl
@@ -17,6 +17,8 @@
 package android.os;
 
 interface IPeripheralManagerClient {
+  void ListGpio(out @utf8InCpp List<String> gpios);
+
   void OpenGpio(@utf8InCpp String name);
 
   void ReleaseGpio(@utf8InCpp String name);
@@ -33,6 +35,8 @@ interface IPeripheralManagerClient {
 
   FileDescriptor GetGpioPollingFd(@utf8InCpp String name);
 
+  void ListSpiBuses(out @utf8InCpp List<String> buses);
+
   void OpenSpiDevice(@utf8InCpp String name);
 
   void ReleaseSpiDevice(@utf8InCpp String name);