Project import
diff --git a/peripheralmanager/.clang-format b/peripheralmanager/.clang-format
new file mode 120000
index 0000000..f412743
--- /dev/null
+++ b/peripheralmanager/.clang-format
@@ -0,0 +1 @@
+../../build/tools/brillo-clang-format
\ No newline at end of file
diff --git a/peripheralmanager/Android.mk b/peripheralmanager/Android.mk
new file mode 100644
index 0000000..178cb8a
--- /dev/null
+++ b/peripheralmanager/Android.mk
@@ -0,0 +1,17 @@
+#
+# Copyright (C) 2015 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 $(call all-subdir-makefiles)
diff --git a/peripheralmanager/MODULE_LICENSE_APACHE2 b/peripheralmanager/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/peripheralmanager/MODULE_LICENSE_APACHE2
diff --git a/peripheralmanager/NOTICE b/peripheralmanager/NOTICE
new file mode 100644
index 0000000..a849a94
--- /dev/null
+++ b/peripheralmanager/NOTICE
@@ -0,0 +1,190 @@
+
+ Copyright (c) 2014-2015, 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.
+
+ 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.
+
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
diff --git a/peripheralmanager/README b/peripheralmanager/README
new file mode 100644
index 0000000..00d0c95
--- /dev/null
+++ b/peripheralmanager/README
@@ -0,0 +1,3 @@
+PeripheralManager
+
+TODO(leecam): Write this file
diff --git a/peripheralmanager/client/Android.mk b/peripheralmanager/client/Android.mk
new file mode 100644
index 0000000..680becc
--- /dev/null
+++ b/peripheralmanager/client/Android.mk
@@ -0,0 +1,80 @@
+#
+# Copyright (C) 2015 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.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+libperipheralman_CommonCFlags := -Wall -Werror -Wno-unused-parameter
+libperipheralman_CommonCFlags += -Wno-sign-promo # for libchrome
+libperipheralman_CommonCIncludes := \
+ $(LOCAL_PATH)/../common \
+ $(LOCAL_PATH)/../include \
+
+libperipheralman_CommonSharedLibraries := \
+ libbinder \
+ libbinderwrapper \
+ libbrillo \
+ libchrome \
+ libutils \
+
+# libperipheralman shared library
+# ========================================================
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := libperipheralman
+LOCAL_CPP_EXTENSION := .cc
+LOCAL_CFLAGS := $(libperipheralman_CommonCFlags)
+LOCAL_C_INCLUDES := $(libperipheralman_CommonCIncludes)
+LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/../include
+LOCAL_SHARED_LIBRARIES := $(libperipheralman_CommonSharedLibraries)
+LOCAL_STATIC_LIBRARIES := libperipheralman_binder
+LOCAL_SRC_FILES := \
+ gpio_impl.cc \
+ i2c_device_impl.cc \
+ led_impl.cc \
+ peripheral_manager_client_impl.cc \
+ spi_device_impl.cc \
+ uart_device_impl.cc \
+ wrapper.cc \
+
+include $(BUILD_SHARED_LIBRARY)
+
+# libperipheralman_tests executable
+# ========================================================
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := libperipheralman_tests
+LOCAL_CPP_EXTENSION := .cc
+LOCAL_CFLAGS := $(libperipheralman_CommonCFlags) -Wno-sign-compare
+LOCAL_C_INCLUDES := $(libperipheralman_CommonCIncludes)
+LOCAL_STATIC_LIBRARIES := libgtest libBionicGtestMain \
+ libperipheralman_binder \
+ libperipheralman_internal_test \
+ libgmock \
+
+LOCAL_SHARED_LIBRARIES := \
+ $(libperipheralman_CommonSharedLibraries) \
+ libperipheralman \
+ libbinderwrapper_test_support \
+
+LOCAL_SRC_FILES := \
+ gpio_unittest.cc \
+ i2c_unittest.cc \
+ led_unittest.cc \
+ peripheral_manager_client_unittest.cc \
+ spi_unittest.cc \
+ uart_unittest.cc \
+
+include $(BUILD_NATIVE_TEST)
diff --git a/peripheralmanager/client/gpio_impl.cc b/peripheralmanager/client/gpio_impl.cc
new file mode 100644
index 0000000..dfe5f83
--- /dev/null
+++ b/peripheralmanager/client/gpio_impl.cc
@@ -0,0 +1,118 @@
+/*
+ * 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();
+}
diff --git a/peripheralmanager/client/gpio_impl.h b/peripheralmanager/client/gpio_impl.h
new file mode 100644
index 0000000..089a4e3
--- /dev/null
+++ b/peripheralmanager/client/gpio_impl.h
@@ -0,0 +1,54 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_GPIO_IMPL_H_
+#define SYSTEM_PERIPHERALMANAGER_GPIO_IMPL_H_
+
+#include <string>
+
+#include <android/os/IPeripheralManagerClient.h>
+#include <utils/StrongPointer.h>
+#include "peripheralmanager/constants.h"
+
+bool ActiveTypeFromInt(int type, android::GpioActiveType* out);
+bool DirectionFromInt(int direction, android::GpioDirection* out);
+bool EdgeTypeFromInt(int type, android::GpioEdgeType* out);
+
+class GpioImpl {
+ public:
+ GpioImpl(const std::string name,
+ android::sp<android::os::IPeripheralManagerClient> client);
+
+ ~GpioImpl();
+
+ int SetDirection(android::GpioDirection direction);
+
+ int SetEdgeTriggerType(android::GpioEdgeType type);
+
+ int SetActiveType(android::GpioActiveType type);
+
+ int SetValue(int value);
+
+ int GetValue(int* value);
+
+ int GetPollingFd(int* fd);
+
+ private:
+ std::string name_;
+ android::sp<android::os::IPeripheralManagerClient> client_;
+};
+
+#endif // SYSTEM_PERIPHERALMANAGER_GPIO_IMPL_H_
diff --git a/peripheralmanager/client/gpio_unittest.cc b/peripheralmanager/client/gpio_unittest.cc
new file mode 100644
index 0000000..f5b54bc
--- /dev/null
+++ b/peripheralmanager/client/gpio_unittest.cc
@@ -0,0 +1,155 @@
+/*
+ * 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 <memory>
+
+#include <binderwrapper/binder_test_base.h>
+#include <binderwrapper/stub_binder_wrapper.h>
+#include <gtest/gtest.h>
+
+#include "gpio_driver_mock.h"
+#include "peripheral_manager.h"
+#include "peripheralmanager/gpio.h"
+#include "peripheralmanager/peripheral_manager_client.h"
+
+using android::GpioDriverInfo;
+using android::GpioDriverInfoBase;
+using android::GpioDriverMock;
+using android::GpioManager;
+using android::PeripheralManager;
+
+// Base class used to test the Gpio C API.
+// As we rely on static, global managers, we cannot run this tests in parallel.
+// Please use -j1 when running theses tests or you may see false negatives.
+class GpioTest : public android::BinderTestBase {
+ public:
+ void SetUp() {
+ android::sp<PeripheralManager> pman(new PeripheralManager);
+ android::String8 interface_desc(pman->getInterfaceDescriptor());
+ binder_wrapper()->SetBinderForService(interface_desc.string(), pman);
+
+ GpioManager* man = GpioManager::GetGpioManager();
+ man->RegisterDriver(std::unique_ptr<GpioDriverInfoBase>(
+ new GpioDriverInfo<GpioDriverMock, void*>(nullptr)));
+
+ man->RegisterGpioSysfs("IO1", 1);
+ man->RegisterGpioSysfs("IO2", 2);
+ man->RegisterGpioSysfs("IO3", 3);
+ man->RegisterGpioSysfs("IO4", 4);
+ man->RegisterGpioSysfs("IO5", 5);
+ }
+
+ void TearDown() { GpioManager::ResetGpioManager(); }
+};
+
+// Test that we list the Gpios available correctly.
+TEST_F(GpioTest, CanListGpios) {
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+ ASSERT_NE(nullptr, client);
+
+ int ngpios;
+ char** list = BPeripheralManagerClient_listGpio(client, &ngpios);
+
+ EXPECT_EQ(5, ngpios);
+ EXPECT_EQ("IO1", std::string(list[0]));
+ EXPECT_EQ("IO2", std::string(list[1]));
+ EXPECT_EQ("IO3", std::string(list[2]));
+ EXPECT_EQ("IO4", std::string(list[3]));
+ EXPECT_EQ("IO5", std::string(list[4]));
+
+ // Free the list.
+ for (int i = 0; i < 5; i++) {
+ free(list[i]);
+ }
+ free(list);
+}
+
+// Test that we can open a Gpio and act on it.
+TEST_F(GpioTest, CanOpenGpio) {
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+ ASSERT_NE(nullptr, client);
+
+ BGpio* gpio;
+ EXPECT_EQ(0, BPeripheralManagerClient_openGpio(client, "IO1", &gpio));
+ ASSERT_NE(nullptr, gpio);
+
+ // Can set the direction. If the direction is invalid, we fail.
+ EXPECT_EQ(0, BGpio_setDirection(gpio, DIRECTION_OUT_INITIALLY_HIGH));
+ EXPECT_EQ(EINVAL, BGpio_setDirection(gpio, 10));
+
+ // Can set the value.
+ EXPECT_EQ(0, BGpio_setValue(gpio, 1));
+
+ // Can set the active type. If the type is unknown, we fail.
+ EXPECT_EQ(0, BGpio_setActiveType(gpio, ACTIVE_LOW));
+ EXPECT_EQ(EINVAL, BGpio_setActiveType(gpio, 5));
+
+ EXPECT_EQ(0, BGpio_setDirection(gpio, DIRECTION_IN));
+
+ // Can read the value from the Gpio.
+ int value;
+ EXPECT_EQ(0, BGpio_getValue(gpio, &value));
+
+ // Setting the value returns an error.
+ EXPECT_EQ(EREMOTEIO, BGpio_setValue(gpio, 1));
+
+ // Can set the edge type. If the type is unknown, we fail.
+ EXPECT_EQ(0, BGpio_setEdgeTriggerType(gpio, RISING_EDGE));
+ EXPECT_EQ(EINVAL, BGpio_setEdgeTriggerType(gpio, -1));
+
+ BGpio_delete(gpio);
+ BPeripheralManagerClient_delete(client);
+}
+
+// Test that openning an unknown Gpio fails.
+TEST_F(GpioTest, OpenningUnknownGpioFails) {
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+ ASSERT_NE(nullptr, client);
+
+ BGpio* gpio = nullptr;
+ EXPECT_EQ(ENODEV,
+ BPeripheralManagerClient_openGpio(client, "unknown", &gpio));
+ EXPECT_EQ(nullptr, gpio);
+
+ BPeripheralManagerClient_delete(client);
+}
+
+// Test that we track ownership correctly (can't open a Gpio twice).
+TEST_F(GpioTest, GpioOnlyOpenedOnce) {
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+ ASSERT_NE(nullptr, client);
+
+ BGpio* gpio1;
+ BGpio* gpio2;
+ BGpio* gpio3;
+
+ EXPECT_EQ(0, BPeripheralManagerClient_openGpio(client, "IO1", &gpio1));
+ EXPECT_NE(nullptr, gpio1);
+
+ // Can't open the same Gpio.
+ EXPECT_EQ(EBUSY, BPeripheralManagerClient_openGpio(client, "IO1", &gpio2));
+
+ // Can open another Gpio.
+ EXPECT_EQ(0, BPeripheralManagerClient_openGpio(client, "IO3", &gpio3));
+
+ // Once we delete the struct, the Gpio is released and we can open it.
+ BGpio_delete(gpio1);
+ EXPECT_EQ(0, BPeripheralManagerClient_openGpio(client, "IO1", &gpio2));
+
+ BGpio_delete(gpio2);
+ BGpio_delete(gpio3);
+ BPeripheralManagerClient_delete(client);
+}
diff --git a/peripheralmanager/client/i2c_device_impl.cc b/peripheralmanager/client/i2c_device_impl.cc
new file mode 100644
index 0000000..01bef5c
--- /dev/null
+++ b/peripheralmanager/client/i2c_device_impl.cc
@@ -0,0 +1,106 @@
+/*
+ * 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 <vector>
+
+#include <peripheralmanager/i2c_device.h>
+
+#include "i2c_device_impl.h"
+
+using android::sp;
+using android::os::IPeripheralManagerClient;
+using android::binder::Status;
+
+I2cDeviceImpl::I2cDeviceImpl(const std::string& name,
+ uint32_t address,
+ sp<IPeripheralManagerClient> client)
+ : name_(name), address_(address), client_(client) {}
+
+I2cDeviceImpl::~I2cDeviceImpl() {
+ client_->ReleaseI2cDevice(name_, address_);
+}
+
+int I2cDeviceImpl::Read(void* data, uint32_t len, uint32_t* bytes_read) {
+ std::vector<uint8_t> read;
+ Status status = client_->I2cRead(
+ name_, address_, &read, len, reinterpret_cast<int32_t*>(bytes_read));
+ memcpy(data, read.data(), *bytes_read);
+ return status.serviceSpecificErrorCode();
+}
+
+int I2cDeviceImpl::ReadRegByte(uint8_t reg, uint8_t* val) {
+ int32_t tmp_val;
+ int ret = client_->I2cReadRegByte(name_, address_, reg, &tmp_val)
+ .serviceSpecificErrorCode();
+ if (!ret) {
+ *val = tmp_val;
+ }
+ return ret;
+}
+
+int I2cDeviceImpl::ReadRegWord(uint8_t reg, uint16_t* val) {
+ int32_t tmp_val;
+ int ret = client_->I2cReadRegWord(name_, address_, reg, &tmp_val)
+ .serviceSpecificErrorCode();
+ if (!ret) {
+ *val = tmp_val;
+ }
+ return ret;
+}
+
+int I2cDeviceImpl::ReadRegBuffer(uint8_t reg,
+ void* data,
+ uint32_t len,
+ uint32_t* bytes_read) {
+ std::vector<uint8_t> read(len);
+ Status status = client_->I2cReadRegBuffer(
+ name_, address_, reg, &read, len, reinterpret_cast<int32_t*>(bytes_read));
+ memcpy(data, read.data(), *bytes_read);
+
+ return status.serviceSpecificErrorCode();
+}
+
+int I2cDeviceImpl::Write(const void* data,
+ uint32_t len,
+ uint32_t* bytes_written) {
+ const uint8_t* bytes = reinterpret_cast<const uint8_t*>(data);
+ std::vector<uint8_t> v(bytes, bytes + len);
+ return client_
+ ->I2cWrite(name_, address_, v, reinterpret_cast<int32_t*>(bytes_written))
+ .serviceSpecificErrorCode();
+}
+
+int I2cDeviceImpl::WriteRegByte(uint8_t reg, uint8_t val) {
+ return client_->I2cWriteRegByte(name_, address_, reg, val)
+ .serviceSpecificErrorCode();
+}
+
+int I2cDeviceImpl::WriteRegWord(uint8_t reg, uint16_t val) {
+ return client_->I2cWriteRegWord(name_, address_, reg, val)
+ .serviceSpecificErrorCode();
+}
+
+int I2cDeviceImpl::WriteRegBuffer(uint8_t reg,
+ const void* data,
+ uint32_t len,
+ uint32_t* bytes_written) {
+ const uint8_t* bytes = reinterpret_cast<const uint8_t*>(data);
+ std::vector<uint8_t> v(bytes, bytes + len);
+ return client_
+ ->I2cWriteRegBuffer(
+ name_, address_, reg, v, reinterpret_cast<int32_t*>(bytes_written))
+ .serviceSpecificErrorCode();
+}
diff --git a/peripheralmanager/client/i2c_device_impl.h b/peripheralmanager/client/i2c_device_impl.h
new file mode 100644
index 0000000..412c662
--- /dev/null
+++ b/peripheralmanager/client/i2c_device_impl.h
@@ -0,0 +1,55 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_I2C_DEVICE_IMPL_H_
+#define SYSTEM_PERIPHERALMANAGER_I2C_DEVICE_IMPL_H_
+
+#include <string>
+
+#include <android/os/IPeripheralManagerClient.h>
+#include <utils/StrongPointer.h>
+
+class I2cDeviceImpl {
+ public:
+ I2cDeviceImpl(const std::string& bus,
+ uint32_t address,
+ android::sp<android::os::IPeripheralManagerClient> client);
+
+ int Read(void* data, uint32_t len, uint32_t* bytes_read);
+ int ReadRegByte(uint8_t reg, uint8_t* val);
+ int ReadRegWord(uint8_t reg, uint16_t* val);
+ int ReadRegBuffer(uint8_t reg,
+ void* data,
+ uint32_t len,
+ uint32_t* bytes_read);
+
+ int Write(const void* data, uint32_t len, uint32_t* bytes_written);
+ int WriteRegByte(uint8_t reg, uint8_t byte);
+ int WriteRegWord(uint8_t reg, uint16_t byte);
+ int WriteRegBuffer(uint8_t reg,
+ const void* data,
+ uint32_t len,
+ uint32_t* bytes_written);
+
+ ~I2cDeviceImpl();
+
+ private:
+ std::string name_;
+ uint32_t address_;
+ android::sp<android::os::IPeripheralManagerClient> client_;
+};
+
+#endif // SYSTEM_PERIPHERALMANAGER_I2C_DEVICE_IMPL_H_
diff --git a/peripheralmanager/client/i2c_unittest.cc b/peripheralmanager/client/i2c_unittest.cc
new file mode 100644
index 0000000..7e95a99
--- /dev/null
+++ b/peripheralmanager/client/i2c_unittest.cc
@@ -0,0 +1,190 @@
+/*
+ * 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 <memory>
+
+#include <binderwrapper/binder_test_base.h>
+#include <binderwrapper/stub_binder_wrapper.h>
+#include <gtest/gtest.h>
+
+#include "fake_i2c_devices.h"
+#include "i2c_driver_i2cdev.h"
+#include "peripheral_manager.h"
+#include "peripheralmanager/i2c_device.h"
+#include "peripheralmanager/peripheral_manager_client.h"
+
+using android::CharDeviceFactory;
+using android::FakeI2cDeviceFactory;
+using android::I2cDriverI2cDev;
+using android::I2cDriverInfo;
+using android::I2cDriverInfoBase;
+using android::I2cManager;
+using android::PeripheralManager;
+
+class I2cTest : public android::BinderTestBase {
+ public:
+ void SetUp() {
+ android::sp<PeripheralManager> pman(new PeripheralManager);
+ android::String8 interface_desc(pman->getInterfaceDescriptor());
+ binder_wrapper()->SetBinderForService(interface_desc.string(), pman);
+
+ I2cManager* man = I2cManager::GetI2cManager();
+ man->RegisterDriver(std::unique_ptr<I2cDriverInfoBase>(
+ new I2cDriverInfo<I2cDriverI2cDev, CharDeviceFactory*>(
+ &i2c_device_factory_)));
+
+ man->RegisterI2cDevBus("I2C0", 0);
+ man->RegisterI2cDevBus("I2C1", 1);
+ }
+
+ void TearDown() { I2cManager::ResetI2cManager(); }
+
+ private:
+ FakeI2cDeviceFactory i2c_device_factory_;
+};
+
+// Test that we can list the I2c buses correctly.
+TEST_F(I2cTest, ListI2cBuses) {
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+
+ int nbuses = -1;
+ char** devices = BPeripheralManagerClient_listI2cBuses(client, &nbuses);
+
+ ASSERT_EQ(2, nbuses);
+ EXPECT_EQ("I2C0", std::string(devices[0]));
+ EXPECT_EQ("I2C1", std::string(devices[1]));
+
+ for (int i = 0; i < nbuses; i++) {
+ free(devices[i]);
+ }
+ free(devices);
+
+ BPeripheralManagerClient_delete(client);
+}
+
+// Test that we can open a device and perform basic operations.
+TEST_F(I2cTest, OpenDevice) {
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+
+ BI2cDevice* device;
+ ASSERT_EQ(
+ 0, BPeripheralManagerClient_openI2cDevice(client, "I2C0", 0x10, &device));
+
+ std::vector<uint8_t> buffer(40, 42);
+
+ uint32_t count = 0;
+
+ // Can write 20 bytes to the device.
+ EXPECT_EQ(0, BI2cDevice_write(device, buffer.data(), 20, &count));
+ EXPECT_EQ(20, count);
+
+ // Can write bytes and words to specific registers.
+ EXPECT_EQ(0, BI2cDevice_writeRegByte(device, 8, 60));
+ EXPECT_EQ(0, BI2cDevice_writeRegWord(device, 9, 2000));
+
+ // Can write 20 bytes to a specific register.
+ count = 0;
+ EXPECT_EQ(0,
+ BI2cDevice_writeRegBuffer(device, 10, buffer.data(), 20, &count));
+ EXPECT_EQ(20, count);
+
+ uint8_t byte;
+ uint16_t word;
+
+ // Can read 20 bytes from the device.
+ buffer.assign(40, 0);
+ count = 0;
+ EXPECT_EQ(0, BI2cDevice_read(device, buffer.data(), 20, &count));
+ EXPECT_EQ(20, count);
+
+ // Can read bytes and word from the device.
+ EXPECT_EQ(0, BI2cDevice_readRegByte(device, 8, &byte));
+ EXPECT_EQ(60, byte);
+
+ EXPECT_EQ(0, BI2cDevice_readRegWord(device, 9, &word));
+ EXPECT_EQ(2000, word);
+
+ // Can read 20 bytes from a specific register.
+ count = 0;
+ buffer.assign(40, 0);
+ EXPECT_EQ(0, BI2cDevice_readRegBuffer(device, 10, buffer.data(), 20, &count));
+ EXPECT_EQ(20, count);
+ for (int i = 0; i < 40; i++) {
+ EXPECT_EQ(i < 20 ? 42 : 0, buffer[i]);
+ }
+
+ BI2cDevice_delete(device);
+ BPeripheralManagerClient_delete(client);
+}
+
+// Test that we can't open the same device twice.
+TEST_F(I2cTest, CantOpenDeviceTwice) {
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+
+ BI2cDevice* device1 = nullptr;
+ BI2cDevice* device2 = nullptr;
+ BI2cDevice* device3 = nullptr;
+ BI2cDevice* device4 = nullptr;
+
+ // Can open the device once.
+ ASSERT_EQ(
+ 0,
+ BPeripheralManagerClient_openI2cDevice(client, "I2C0", 0x10, &device1));
+ ASSERT_NE(nullptr, device1);
+
+ // Can open a device on the same address on a different bus.
+ ASSERT_EQ(
+ 0,
+ BPeripheralManagerClient_openI2cDevice(client, "I2C1", 0x10, &device2));
+ ASSERT_NE(nullptr, device2);
+
+ // Can open another device on the same bus.
+ ASSERT_EQ(
+ 0,
+ BPeripheralManagerClient_openI2cDevice(client, "I2C0", 0x13, &device3));
+ ASSERT_NE(nullptr, device3);
+
+ // Can't open a device already in use.
+ ASSERT_EQ(
+ EBUSY,
+ BPeripheralManagerClient_openI2cDevice(client, "I2C0", 0x10, &device4));
+ ASSERT_EQ(nullptr, device4);
+
+ // After releasing the device, we can re-open it.
+ BI2cDevice_delete(device1);
+ ASSERT_EQ(
+ 0,
+ BPeripheralManagerClient_openI2cDevice(client, "I2C0", 0x10, &device4));
+ ASSERT_NE(nullptr, device4);
+
+ BI2cDevice_delete(device2);
+ BI2cDevice_delete(device3);
+ BI2cDevice_delete(device4);
+ BPeripheralManagerClient_delete(client);
+}
+
+// Test that we cleanly fail to open an unknown device.
+TEST_F(I2cTest, CantOpenUnknownDevice) {
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+
+ BI2cDevice* device = nullptr;
+ ASSERT_EQ(
+ ENODEV,
+ BPeripheralManagerClient_openI2cDevice(client, "I2C5", 0x10, &device));
+ ASSERT_EQ(nullptr, device);
+
+ BPeripheralManagerClient_delete(client);
+}
diff --git a/peripheralmanager/client/led_impl.cc b/peripheralmanager/client/led_impl.cc
new file mode 100644
index 0000000..164cf2b
--- /dev/null
+++ b/peripheralmanager/client/led_impl.cc
@@ -0,0 +1,51 @@
+/*
+ * 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 <led_impl.h>
+
+using android::binder::Status;
+using android::os::IPeripheralManagerClient;
+using android::sp;
+
+LedImpl::LedImpl(const std::string& name, sp<IPeripheralManagerClient> client)
+ : name_(name), client_(client) {}
+
+LedImpl::~LedImpl() {
+ client_->ReleaseLed(name_);
+}
+
+int LedImpl::GetBrightness(uint32_t* brightness) {
+ int val;
+ Status status = client_->LedGetBrightness(name_, &val);
+ if (status.isOk())
+ *brightness = static_cast<uint32_t>(val);
+
+ return status.serviceSpecificErrorCode();
+}
+
+int LedImpl::GetMaxBrightness(uint32_t* max_brightness) {
+ int val;
+ Status status = client_->LedGetMaxBrightness(name_, &val);
+ if (status.isOk())
+ *max_brightness = static_cast<uint32_t>(val);
+
+ return status.serviceSpecificErrorCode();
+}
+
+int LedImpl::SetBrightness(uint32_t brightness) {
+ return client_->LedSetBrightness(name_, brightness)
+ .serviceSpecificErrorCode();
+}
diff --git a/peripheralmanager/client/led_impl.h b/peripheralmanager/client/led_impl.h
new file mode 100644
index 0000000..f848864
--- /dev/null
+++ b/peripheralmanager/client/led_impl.h
@@ -0,0 +1,40 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_LED_IMPL_H_
+#define SYSTEM_PERIPHERALMANAGER_LED_IMPL_H_
+
+#include <string>
+
+#include <android/os/IPeripheralManagerClient.h>
+#include <utils/StrongPointer.h>
+
+class LedImpl {
+ public:
+ LedImpl(const std::string& name,
+ android::sp<android::os::IPeripheralManagerClient> client);
+ ~LedImpl();
+
+ int GetBrightness(uint32_t* brightness);
+ int GetMaxBrightness(uint32_t* max_brightness);
+ int SetBrightness(uint32_t brightness);
+
+ private:
+ std::string name_;
+ android::sp<android::os::IPeripheralManagerClient> client_;
+};
+
+#endif // SYSTEM_PERIPHERALMANAGER_LED_IMPL_H_
diff --git a/peripheralmanager/client/led_unittest.cc b/peripheralmanager/client/led_unittest.cc
new file mode 100644
index 0000000..04c10d4
--- /dev/null
+++ b/peripheralmanager/client/led_unittest.cc
@@ -0,0 +1,162 @@
+/*
+ * 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 <memory>
+
+#include <base/files/file_util.h>
+#include <base/files/scoped_temp_dir.h>
+#include <binderwrapper/binder_test_base.h>
+#include <binderwrapper/stub_binder_wrapper.h>
+#include <gtest/gtest.h>
+
+#include "led_driver_sysfs.h"
+#include "led_manager.h"
+#include "peripheral_manager.h"
+#include "peripheralmanager/led.h"
+#include "peripheralmanager/peripheral_manager_client.h"
+
+using android::LedDriverInfo;
+using android::LedDriverInfoBase;
+using android::LedDriverSysfs;
+using android::LedManager;
+using android::PeripheralManager;
+
+class LedTest : public android::BinderTestBase {
+ public:
+ void SetUp() {
+ CHECK(dir_.CreateUniqueTempDir());
+
+ CreateLed("led1", 255, 0);
+ CreateLed("led2", 1000, 0);
+
+ led_path_prefix_ = dir_.path().value() + "/";
+
+ // Initialize the peripheral manager with the stub binder wrapper.
+ android::sp<PeripheralManager> pman(new PeripheralManager);
+ android::String8 interface_desc(pman->getInterfaceDescriptor());
+ binder_wrapper()->SetBinderForService(interface_desc.string(), pman);
+
+ LedManager* man = LedManager::GetLedManager();
+
+ // Register the testing version of the LED driver and the fake LEDs.
+ man->RegisterDriver(std::unique_ptr<LedDriverInfoBase>(
+ new LedDriverInfo<LedDriverSysfs, std::string*>(&led_path_prefix_)));
+
+ man->RegisterLedSysfs("LED1", "led1");
+ man->RegisterLedSysfs("LED2", "led2");
+ }
+
+ void CreateLed(const std::string& name, int max_brightness, int brightness) {
+ base::FilePath led(dir_.path().Append(name));
+ base::CreateDirectory(led);
+
+ std::string b_str = std::to_string(brightness);
+ std::string mb_str = std::to_string(max_brightness);
+
+ ASSERT_EQ(
+ b_str.size(),
+ base::WriteFile(led.Append("brightness"), b_str.c_str(), b_str.size()));
+ ASSERT_EQ(mb_str.size(),
+ base::WriteFile(
+ led.Append("max_brightness"), mb_str.c_str(), mb_str.size()));
+ }
+
+ void TearDown() { LedManager::ResetLedManager(); }
+
+ private:
+ base::ScopedTempDir dir_;
+ std::string led_path_prefix_;
+};
+
+// Test that we can list the available LEDs.
+TEST_F(LedTest, CanListLeds) {
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+ ASSERT_NE(nullptr, client);
+
+ int nleds = -1;
+ char** leds = BPeripheralManagerClient_listLeds(client, &nleds);
+
+ EXPECT_EQ(2, nleds);
+ EXPECT_EQ("LED1", std::string(leds[0]));
+ EXPECT_EQ("LED2", std::string(leds[1]));
+
+ for (int i = 0; i < nleds; i++) {
+ free(leds[i]);
+ }
+ free(leds);
+
+ BPeripheralManagerClient_delete(client);
+}
+
+// Test that we can open an LED and act on it.
+TEST_F(LedTest, CanOpenLed) {
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+ ASSERT_NE(nullptr, client);
+
+ BLed* led;
+
+ ASSERT_EQ(0, BPeripheralManagerClient_openLed(client, "LED1", &led));
+
+ uint32_t max_brightness = 0;
+ EXPECT_EQ(0, BLed_getMaxBrightness(led, &max_brightness));
+ EXPECT_EQ(255, max_brightness);
+
+ uint32_t brightness = 0;
+ EXPECT_EQ(0, BLed_setBrightness(led, 10));
+ EXPECT_EQ(0, BLed_getBrightness(led, &brightness));
+ EXPECT_EQ(10, brightness);
+
+ BLed_delete(led);
+ BPeripheralManagerClient_delete(client);
+}
+
+// Test that we can't open an unexisting LED.
+TEST_F(LedTest, OpenningUnknownLed) {
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+ ASSERT_NE(nullptr, client);
+
+ BLed* led = nullptr;
+ EXPECT_EQ(ENODEV, BPeripheralManagerClient_openLed(client, "hello", &led));
+ EXPECT_EQ(nullptr, led);
+
+ BPeripheralManagerClient_delete(client);
+}
+
+// Test that we can't open an LED twice.
+TEST_F(LedTest, HandleConcurrentAccesses) {
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+ ASSERT_NE(nullptr, client);
+
+ // Can open LED1.
+ BLed* led1;
+ EXPECT_EQ(0, BPeripheralManagerClient_openLed(client, "LED1", &led1));
+
+ // Fails to open it twice.
+ BLed* led2;
+ EXPECT_EQ(EBUSY, BPeripheralManagerClient_openLed(client, "LED1", &led2));
+
+ // Can still open another LED.
+ BLed* led3;
+ EXPECT_EQ(0, BPeripheralManagerClient_openLed(client, "LED2", &led3));
+
+ // Once the LED is released, we can take ownership of it.
+ BLed_delete(led1);
+ EXPECT_EQ(0, BPeripheralManagerClient_openLed(client, "LED1", &led2));
+
+ BLed_delete(led2);
+ BLed_delete(led3);
+ BPeripheralManagerClient_delete(client);
+}
diff --git a/peripheralmanager/client/peripheral_manager_client_impl.cc b/peripheralmanager/client/peripheral_manager_client_impl.cc
new file mode 100644
index 0000000..4fdb731
--- /dev/null
+++ b/peripheralmanager/client/peripheral_manager_client_impl.cc
@@ -0,0 +1,102 @@
+/*
+ * 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_impl.h"
+
+#include <android/os/IPeripheralManager.h>
+#include <binderwrapper/binder_wrapper.h>
+
+using android::binder::Status;
+
+bool PeripheralManagerClientImpl::Init() {
+ auto wrapper = android::interface_cast<android::os::IPeripheralManager>(
+ android::BinderWrapper::GetOrCreateInstance()->GetService(
+ "android.os.IPeripheralManager"));
+ lifeline_ = new android::BBinder;
+
+ return wrapper->GetClient(lifeline_, &client_).isOk();
+}
+
+int PeripheralManagerClientImpl::OpenGpio(const std::string& name,
+ std::unique_ptr<GpioImpl>* gpio) {
+ Status status = client_->OpenGpio(name);
+ if (status.isOk()) {
+ gpio->reset(new GpioImpl(name, client_));
+ }
+ 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) {
+ Status status = client_->OpenSpiDevice(name);
+ if (status.isOk()) {
+ 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();
+}
+
+int PeripheralManagerClientImpl::ListLeds(std::vector<std::string>* leds) {
+ return client_->ListLeds(leds).serviceSpecificErrorCode();
+}
+
+int PeripheralManagerClientImpl::OpenLed(const std::string& name,
+ std::unique_ptr<LedImpl>* led) {
+ Status status = client_->OpenLed(name);
+ if (status.isOk()) {
+ led->reset(new LedImpl(name, client_));
+ }
+ return status.serviceSpecificErrorCode();
+}
+
+int PeripheralManagerClientImpl::OpenI2cDevice(
+ const std::string& name,
+ uint32_t address,
+ std::unique_ptr<I2cDeviceImpl>* device) {
+ Status status = client_->OpenI2cDevice(name, address);
+ if (status.isOk()) {
+ device->reset(new I2cDeviceImpl(name, address, client_));
+ }
+ return status.serviceSpecificErrorCode();
+}
+
+int PeripheralManagerClientImpl::ListI2cBuses(std::vector<std::string>* buses) {
+ return client_->ListI2cBuses(buses).serviceSpecificErrorCode();
+}
+
+int PeripheralManagerClientImpl::OpenUartDevice(
+ const std::string& name, std::unique_ptr<UartDeviceImpl>* device) {
+ Status status = client_->OpenUartDevice(name);
+ if (status.isOk()) {
+ device->reset(new UartDeviceImpl(name, client_));
+ }
+ return status.serviceSpecificErrorCode();
+}
+
+int PeripheralManagerClientImpl::ListUartDevices(
+ std::vector<std::string>* list) {
+ return client_->ListUartDevices(list).serviceSpecificErrorCode();
+}
diff --git a/peripheralmanager/client/peripheral_manager_client_impl.h b/peripheralmanager/client/peripheral_manager_client_impl.h
new file mode 100644
index 0000000..aba4739
--- /dev/null
+++ b/peripheralmanager/client/peripheral_manager_client_impl.h
@@ -0,0 +1,59 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_PERIPHERAL_MANAGER_CLIENT_IMPL_H_
+#define SYSTEM_PERIPHERALMANAGER_PERIPHERAL_MANAGER_CLIENT_IMPL_H_
+
+#include <android/os/IPeripheralManagerClient.h>
+#include <utils/StrongPointer.h>
+
+#include "gpio_impl.h"
+#include "i2c_device_impl.h"
+#include "led_impl.h"
+#include "spi_device_impl.h"
+#include "uart_device_impl.h"
+
+class PeripheralManagerClientImpl {
+ public:
+ PeripheralManagerClientImpl() = default;
+
+ 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);
+
+ int OpenLed(const std::string& name, std::unique_ptr<LedImpl>* device);
+ int ListLeds(std::vector<std::string>* leds);
+
+ int OpenI2cDevice(const std::string& name,
+ uint32_t address,
+ std::unique_ptr<I2cDeviceImpl>* device);
+ int ListI2cBuses(std::vector<std::string>* buses);
+
+ int OpenUartDevice(const std::string& name,
+ std::unique_ptr<UartDeviceImpl>* device);
+ int ListUartDevices(std::vector<std::string>* buses);
+
+ private:
+ android::sp<android::os::IPeripheralManagerClient> client_;
+ android::sp<android::IBinder> lifeline_;
+};
+
+#endif // SYSTEM_PERIPHERALMANAGER_PERIPHERAL_MANAGER_CLIENT_IMPL_H_
diff --git a/peripheralmanager/client/peripheral_manager_client_unittest.cc b/peripheralmanager/client/peripheral_manager_client_unittest.cc
new file mode 100644
index 0000000..e75af24
--- /dev/null
+++ b/peripheralmanager/client/peripheral_manager_client_unittest.cc
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2015 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 <peripheralmanager/peripheral_manager_client.h>
+
+#include "gtest/gtest.h"
+
+namespace android {
+
+TEST(PeripheralManagerClient, Init) {
+}
+
+} // namespace android
diff --git a/peripheralmanager/client/spi_device_impl.cc b/peripheralmanager/client/spi_device_impl.cc
new file mode 100644
index 0000000..d9bab6d
--- /dev/null
+++ b/peripheralmanager/client/spi_device_impl.cc
@@ -0,0 +1,84 @@
+/*
+ * 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 <vector>
+
+#include <peripheralmanager/spi_device.h>
+
+#include "spi_device_impl.h"
+
+using android::sp;
+using android::os::IPeripheralManagerClient;
+using android::binder::Status;
+
+SpiDeviceImpl::SpiDeviceImpl(const std::string& name,
+ sp<IPeripheralManagerClient> client)
+ : name_(name), client_(client) {}
+
+SpiDeviceImpl::~SpiDeviceImpl() {
+ client_->ReleaseSpiDevice(name_);
+}
+
+int SpiDeviceImpl::WriteByte(uint8_t byte) {
+ return client_->SpiDeviceWriteByte(name_, byte).serviceSpecificErrorCode();
+}
+
+int SpiDeviceImpl::WriteBuffer(const uint8_t* data, size_t len) {
+ std::vector<uint8_t> v(data, data + len);
+ return client_->SpiDeviceWriteBuffer(name_, v).serviceSpecificErrorCode();
+}
+
+int SpiDeviceImpl::Transfer(const uint8_t* tx_data,
+ uint8_t* rx_data,
+ size_t len) {
+ std::unique_ptr<std::vector<uint8_t>> sent;
+ std::unique_ptr<std::vector<uint8_t>> received;
+
+ if (tx_data == nullptr)
+ return EINVAL;
+
+ sent.reset(new std::vector<uint8_t>(tx_data, tx_data + len));
+
+ Status status = client_->SpiDeviceTransfer(name_, sent, &received, len);
+ if (status.isOk() && rx_data)
+ memcpy(rx_data, received->data(), len);
+ return status.serviceSpecificErrorCode();
+}
+
+int SpiDeviceImpl::SetFrequency(uint32_t freq_hz) {
+ return client_->SpiDeviceSetFrequency(name_, freq_hz)
+ .serviceSpecificErrorCode();
+}
+
+int SpiDeviceImpl::SetMode(int mode) {
+ return client_->SpiDeviceSetMode(name_, mode).serviceSpecificErrorCode();
+}
+
+int SpiDeviceImpl::SetBitJustification(int justification) {
+ return client_
+ ->SpiDeviceSetBitJustification(name_, justification == SPI_LSB_FIRST)
+ .serviceSpecificErrorCode();
+}
+
+int SpiDeviceImpl::SetBitsPerWord(uint32_t bits_per_word) {
+ return client_->SpiDeviceSetBitsPerWord(name_, bits_per_word)
+ .serviceSpecificErrorCode();
+}
+
+int SpiDeviceImpl::SetDelay(uint16_t delay_usecs) {
+ return client_->SpiDeviceSetDelay(name_, delay_usecs)
+ .serviceSpecificErrorCode();
+}
diff --git a/peripheralmanager/client/spi_device_impl.h b/peripheralmanager/client/spi_device_impl.h
new file mode 100644
index 0000000..ed076d5
--- /dev/null
+++ b/peripheralmanager/client/spi_device_impl.h
@@ -0,0 +1,52 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_SPI_DEVICE_IMPL_H_
+#define SYSTEM_PERIPHERALMANAGER_SPI_DEVICE_IMPL_H_
+
+#include <string>
+
+#include <android/os/IPeripheralManagerClient.h>
+#include <utils/StrongPointer.h>
+
+class SpiDeviceImpl {
+ public:
+ SpiDeviceImpl(const std::string& bus,
+ android::sp<android::os::IPeripheralManagerClient> client);
+ ~SpiDeviceImpl();
+
+ int WriteByte(uint8_t byte);
+
+ int WriteBuffer(const uint8_t* data, size_t len);
+
+ int Transfer(const uint8_t* tx_data, uint8_t* rx_data, size_t len);
+
+ int SetFrequency(uint32_t speed_hz);
+
+ int SetMode(int mode);
+
+ int SetBitJustification(int bit_justification);
+
+ int SetBitsPerWord(uint32_t bits_per_word);
+
+ int SetDelay(uint16_t delay_usecs);
+
+ private:
+ std::string name_;
+ android::sp<android::os::IPeripheralManagerClient> client_;
+};
+
+#endif // SYSTEM_PERIPHERALMANAGER_SPI_DEVICE_IMPL_H_
diff --git a/peripheralmanager/client/spi_unittest.cc b/peripheralmanager/client/spi_unittest.cc
new file mode 100644
index 0000000..cc8a3fb
--- /dev/null
+++ b/peripheralmanager/client/spi_unittest.cc
@@ -0,0 +1,200 @@
+/*
+ * 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 <memory>
+
+#include <binderwrapper/binder_test_base.h>
+#include <binderwrapper/stub_binder_wrapper.h>
+#include <gtest/gtest.h>
+
+#include "fake_devices.h"
+#include "peripheral_manager.h"
+#include "peripheralmanager/peripheral_manager_client.h"
+#include "peripheralmanager/spi_device.h"
+#include "spi_driver_spidev.h"
+
+using android::CharDeviceFactory;
+using android::FakeDeviceFactory;
+using android::SpiDriverInfo;
+using android::SpiDriverInfoBase;
+using android::SpiDriverSpiDev;
+using android::SpiManager;
+using android::PeripheralManager;
+
+// Base class used to test the Spi C API.
+// As we rely on static, global managers, we cannot run this tests in parallel.
+// Please use -j1 when running theses tests or you may see false negatives.
+class SpiTest : public android::BinderTestBase {
+ public:
+ void SetUp() {
+ android::sp<PeripheralManager> pman(new PeripheralManager);
+ android::String8 interface_desc(pman->getInterfaceDescriptor());
+ binder_wrapper()->SetBinderForService(interface_desc.string(), pman);
+
+ SpiManager* man = SpiManager::GetSpiManager();
+
+ man->GetSpiDevBuses();
+ man->RegisterDriver(std::unique_ptr<SpiDriverInfoBase>(
+ new SpiDriverInfo<SpiDriverSpiDev, CharDeviceFactory*>(
+ &device_factory_)));
+
+ man->RegisterSpiDevBus("SPI_A", 1, 0);
+ man->RegisterSpiDevBus("SPI_B", 1, 1);
+ }
+
+ void TearDown() { SpiManager::ResetSpiManager(); }
+
+ private:
+ FakeDeviceFactory device_factory_;
+};
+
+// Test that we can list the available devices.
+TEST_F(SpiTest, ListSpiDevices) {
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+
+ int ndev = -1;
+ char** devices = BPeripheralManagerClient_listSpiBuses(client, &ndev);
+
+ ASSERT_EQ(2, ndev);
+ EXPECT_EQ("SPI_A", std::string(devices[0]));
+ EXPECT_EQ("SPI_B", std::string(devices[1]));
+
+ for (int i = 0; i < ndev; i++) {
+ free(devices[i]);
+ }
+ free(devices);
+
+ BPeripheralManagerClient_delete(client);
+}
+
+// Test that we can open a device and use the basic functions.
+TEST_F(SpiTest, OpenSpiDevice) {
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+
+ BSpiDevice* device = nullptr;
+ ASSERT_EQ(0,
+ BPeripheralManagerClient_openSpiDevice(client, "SPI_A", &device));
+ ASSERT_NE(nullptr, device);
+
+ EXPECT_EQ(0, BSpiDevice_writeByte(device, 0x10));
+
+ std::vector<uint8_t> v = {1, 2, 3, 4};
+ EXPECT_EQ(0, BSpiDevice_writeBuffer(device, v.data(), v.size()));
+
+ BSpiDevice_delete(device);
+ BPeripheralManagerClient_delete(client);
+}
+
+// Test that the transfer function behave correctly.
+TEST_F(SpiTest, Transfer) {
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+
+ BSpiDevice* device = nullptr;
+ ASSERT_EQ(0,
+ BPeripheralManagerClient_openSpiDevice(client, "SPI_A", &device));
+ ASSERT_NE(nullptr, device);
+
+ // Passing an empty return pointer is valid.
+ std::vector<uint8_t> v = {0, 0, 0, 0};
+ uint8_t received[4];
+ EXPECT_EQ(0, BSpiDevice_transfer(device, v.data(), nullptr, v.size()));
+
+ // Passing an empty send pointer is invalid.
+ EXPECT_EQ(EINVAL, BSpiDevice_transfer(device, nullptr, &received, 4));
+
+ BSpiDevice_delete(device);
+ BPeripheralManagerClient_delete(client);
+}
+
+// Test that we can configure the device correctly and that we fail cleanly if
+// the configuration is incorrect.
+TEST_F(SpiTest, SetConfiguration) {
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+
+ BSpiDevice* device = nullptr;
+ ASSERT_EQ(0,
+ BPeripheralManagerClient_openSpiDevice(client, "SPI_A", &device));
+ ASSERT_NE(nullptr, device);
+
+ // We can set the mode and detect an invalid mode.
+ EXPECT_EQ(0, BSpiDevice_setMode(device, SPI_MODE0));
+ EXPECT_EQ(0, BSpiDevice_setMode(device, SPI_MODE1));
+ EXPECT_EQ(0, BSpiDevice_setMode(device, SPI_MODE2));
+ EXPECT_EQ(0, BSpiDevice_setMode(device, SPI_MODE3));
+ EXPECT_EQ(EINVAL, BSpiDevice_setMode(device, SPI_MODE3 + 1));
+
+ // We can set the bit justification and detect an invalid justification.
+ EXPECT_EQ(0, BSpiDevice_setBitJustification(device, SPI_LSB_FIRST));
+ EXPECT_EQ(0, BSpiDevice_setBitJustification(device, SPI_MSB_FIRST));
+ EXPECT_EQ(EINVAL, BSpiDevice_setBitJustification(device, SPI_MSB_FIRST + 1));
+
+ // We can set the frequency.
+ EXPECT_EQ(0, BSpiDevice_setFrequency(device, 100000));
+
+ // We can set the number of bits per word.
+ EXPECT_EQ(0, BSpiDevice_setBitsPerWord(device, 16));
+
+ // We can set the delay between transfers.
+ EXPECT_EQ(0, BSpiDevice_setDelay(device, 100));
+
+ BSpiDevice_delete(device);
+ BPeripheralManagerClient_delete(client);
+}
+
+// Test that we fail when trying to open the same device twice.
+TEST_F(SpiTest, CantOpenDeviceTwice) {
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+
+ BSpiDevice* device1 = nullptr;
+ BSpiDevice* device2 = nullptr;
+ BSpiDevice* device3 = nullptr;
+
+ // Can open SPI_A once.
+ ASSERT_EQ(0,
+ BPeripheralManagerClient_openSpiDevice(client, "SPI_A", &device1));
+ ASSERT_NE(nullptr, device1);
+
+ // The device can't be opened a second time because it is busy.
+ ASSERT_EQ(EBUSY,
+ BPeripheralManagerClient_openSpiDevice(client, "SPI_A", &device2));
+ ASSERT_EQ(nullptr, device2);
+
+ // Can open another device.
+ ASSERT_EQ(0,
+ BPeripheralManagerClient_openSpiDevice(client, "SPI_B", &device3));
+
+ // Once released, we can re-open the device.
+ BSpiDevice_delete(device1);
+ ASSERT_EQ(0,
+ BPeripheralManagerClient_openSpiDevice(client, "SPI_A", &device2));
+
+ BSpiDevice_delete(device2);
+ BSpiDevice_delete(device3);
+ BPeripheralManagerClient_delete(client);
+}
+
+// Test that we fail when trying to open an unknown device.
+TEST_F(SpiTest, CantOpenUnknownDevice) {
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+
+ BSpiDevice* device = nullptr;
+ ASSERT_EQ(
+ ENODEV,
+ BPeripheralManagerClient_openSpiDevice(client, "SPI_UNKOWN", &device));
+ ASSERT_EQ(nullptr, device);
+
+ BPeripheralManagerClient_delete(client);
+}
diff --git a/peripheralmanager/client/uart_device_impl.cc b/peripheralmanager/client/uart_device_impl.cc
new file mode 100644
index 0000000..becfd62
--- /dev/null
+++ b/peripheralmanager/client/uart_device_impl.cc
@@ -0,0 +1,57 @@
+/*
+ * 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 "uart_device_impl.h"
+
+#include <binder/Status.h>
+
+using android::binder::Status;
+
+UartDeviceImpl::UartDeviceImpl(
+ const std::string& name,
+ android::sp<android::os::IPeripheralManagerClient> client)
+ : name_(name), client_(client) {}
+
+UartDeviceImpl::~UartDeviceImpl() {
+ client_->ReleaseUartDevice(name_);
+}
+
+int UartDeviceImpl::SetBaudrate(uint32_t baudrate) {
+ return client_->SetUartDeviceBaudrate(name_, baudrate)
+ .serviceSpecificErrorCode();
+}
+
+int UartDeviceImpl::Write(const void* data,
+ uint32_t size,
+ uint32_t* bytes_written) {
+ const uint8_t* d = reinterpret_cast<const uint8_t*>(data);
+ return client_
+ ->UartDeviceWrite(name_,
+ std::vector<uint8_t>(d, d + size),
+ reinterpret_cast<int32_t*>(bytes_written))
+ .serviceSpecificErrorCode();
+}
+
+int UartDeviceImpl::Read(void* data, uint32_t size, uint32_t* bytes_read) {
+ std::vector<uint8_t> v;
+ Status status = client_->UartDeviceRead(
+ name_, &v, size, reinterpret_cast<int32_t*>(bytes_read));
+ if (status.isOk()) {
+ memcpy(data, v.data(), *bytes_read);
+ }
+
+ return status.serviceSpecificErrorCode();
+}
diff --git a/peripheralmanager/client/uart_device_impl.h b/peripheralmanager/client/uart_device_impl.h
new file mode 100644
index 0000000..72d5d4a
--- /dev/null
+++ b/peripheralmanager/client/uart_device_impl.h
@@ -0,0 +1,43 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_UART_DEVICE_IMPL_H_
+#define SYSTEM_PERIPHERALMANAGER_UART_DEVICE_IMPL_H_
+
+#include <string>
+
+#include <android/os/IPeripheralManagerClient.h>
+#include <utils/StrongPointer.h>
+
+class UartDeviceImpl {
+ public:
+ UartDeviceImpl(const std::string& name,
+ android::sp<android::os::IPeripheralManagerClient> client);
+
+ ~UartDeviceImpl();
+
+ int SetBaudrate(uint32_t baudrate);
+
+ int Write(const void* data, uint32_t size, uint32_t* bytes_written);
+
+ int Read(void* data, uint32_t size, uint32_t* bytes_read);
+
+ private:
+ std::string name_;
+ android::sp<android::os::IPeripheralManagerClient> client_;
+};
+
+#endif // SYSTEM_PERIPHERALMANAGER_UART_DEVICE_IMPL_H_
diff --git a/peripheralmanager/client/uart_unittest.cc b/peripheralmanager/client/uart_unittest.cc
new file mode 100644
index 0000000..ff46433
--- /dev/null
+++ b/peripheralmanager/client/uart_unittest.cc
@@ -0,0 +1,151 @@
+/*
+ * 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 <memory>
+
+#include <binderwrapper/binder_test_base.h>
+#include <binderwrapper/stub_binder_wrapper.h>
+#include <gtest/gtest.h>
+
+#include "fake_devices.h"
+#include "peripheral_manager.h"
+#include "peripheralmanager/peripheral_manager_client.h"
+#include "peripheralmanager/uart_device.h"
+#include "uart_driver_sysfs.h"
+
+using android::CharDeviceFactory;
+using android::FakeDeviceFactory;
+using android::UartDriverInfo;
+using android::UartDriverInfoBase;
+using android::UartDriverSysfs;
+using android::UartManager;
+using android::PeripheralManager;
+
+// Base class used to test the Uart C API.
+// As we rely on static, global managers, we cannot run this tests in parallel.
+// Please use -j1 when running theses tests or you may see false negatives.
+class UartTest : public android::BinderTestBase {
+ public:
+ void SetUp() {
+ android::sp<PeripheralManager> pman(new PeripheralManager);
+ android::String8 interface_desc(pman->getInterfaceDescriptor());
+ binder_wrapper()->SetBinderForService(interface_desc.string(), pman);
+
+ UartManager* man = UartManager::GetManager();
+
+ man->RegisterDriver(std::unique_ptr<UartDriverInfoBase>(
+ new UartDriverInfo<UartDriverSysfs, CharDeviceFactory*>(
+ &device_factory_)));
+
+ man->RegisterUartDevice("UART0", "/dev/ttyuart0");
+ }
+
+ void TearDown() { UartManager::ResetManager(); }
+
+ private:
+ FakeDeviceFactory device_factory_;
+};
+
+// Test that we can list the available devices.
+TEST_F(UartTest, ListDevices) {
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+
+ int n = 0;
+ char** list = BPeripheralManagerClient_listUartDevices(client, &n);
+
+ ASSERT_EQ(1, n);
+ ASSERT_EQ("UART0", std::string(list[0]));
+
+ free(list[0]);
+ free(list);
+
+ BPeripheralManagerClient_delete(client);
+}
+
+// Test that we can open a uart device and set the baudrate.
+TEST_F(UartTest, OpenDevice) {
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+
+ BUartDevice* device;
+ ASSERT_EQ(0,
+ BPeripheralManagerClient_openUartDevice(client, "UART0", &device));
+
+ // Can set a valid baudrate.
+ ASSERT_EQ(0, BUartDevice_setBaudrate(device, 115200));
+
+ // Setting an invalid baudrate should return an error.
+ ASSERT_EQ(EINVAL, BUartDevice_setBaudrate(device, 12345));
+
+ BUartDevice_delete(device);
+ BPeripheralManagerClient_delete(client);
+}
+
+// Test that we can detect when a device is accessed twice and report an
+// appropriate error.
+TEST_F(UartTest, HandlesConflict) {
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+
+ BUartDevice* device_a;
+ BUartDevice* device_b;
+
+ // Can open UART0 once.
+ ASSERT_EQ(
+ 0, BPeripheralManagerClient_openUartDevice(client, "UART0", &device_a));
+
+ // Can't open it twice.
+ ASSERT_EQ(
+ EBUSY,
+ BPeripheralManagerClient_openUartDevice(client, "UART0", &device_b));
+
+ // Can open it again once closed.
+ BUartDevice_delete(device_a);
+ ASSERT_EQ(
+ 0, BPeripheralManagerClient_openUartDevice(client, "UART0", &device_b));
+
+ BUartDevice_delete(device_b);
+ BPeripheralManagerClient_delete(client);
+}
+
+// Test that we report the right error when trying to open an unknown device.
+TEST_F(UartTest, UnknownDevice) {
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+
+ BUartDevice* device;
+ ASSERT_EQ(
+ ENODEV,
+ BPeripheralManagerClient_openUartDevice(client, "unknown", &device));
+
+ BPeripheralManagerClient_delete(client);
+}
+
+// Test that we can read and write to a device.
+TEST_F(UartTest, ReadWrite) {
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+
+ BUartDevice* device;
+ ASSERT_EQ(0,
+ BPeripheralManagerClient_openUartDevice(client, "UART0", &device));
+
+ char buf[40];
+ uint32_t nwritten;
+ EXPECT_EQ(0, BUartDevice_write(device, buf, 40, &nwritten));
+
+ uint32_t nread;
+ EXPECT_EQ(0, BUartDevice_read(device, buf, 40, &nread));
+
+ BUartDevice_delete(device);
+ BPeripheralManagerClient_delete(client);
+}
diff --git a/peripheralmanager/client/wrapper.cc b/peripheralmanager/client/wrapper.cc
new file mode 100644
index 0000000..f9cc3dc
--- /dev/null
+++ b/peripheralmanager/client/wrapper.cc
@@ -0,0 +1,383 @@
+/*
+ * 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 <utils/StrongPointer.h>
+#include <memory>
+
+#include "gpio_impl.h"
+#include "led_impl.h"
+#include "peripheral_manager_client_impl.h"
+#include "peripheralmanager/peripheral_manager_client.h"
+#include "spi_device_impl.h"
+#include "uart_device_impl.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;
+};
+
+struct BGpio {
+ GpioImpl* impl;
+};
+
+struct BSpiDevice {
+ SpiDeviceImpl* impl;
+};
+
+struct BLed {
+ LedImpl* impl;
+};
+
+struct BI2cDevice {
+ I2cDeviceImpl* impl;
+};
+
+struct BUartDevice {
+ UartDeviceImpl* impl;
+};
+
+BPeripheralManagerClient* BPeripheralManagerClient_new() {
+ std::unique_ptr<PeripheralManagerClientImpl> impl(
+ new PeripheralManagerClientImpl);
+ if (impl->Init()) {
+ return new BPeripheralManagerClient{impl.release()};
+ }
+
+ return NULL;
+}
+
+void BPeripheralManagerClient_delete(BPeripheralManagerClient* client) {
+ delete client->impl;
+ delete client;
+}
+
+// GPIO API
+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) {
+ std::unique_ptr<GpioImpl> tmp;
+ int ret = client->impl->OpenGpio(name, &tmp);
+ if (!ret) {
+ *gpio = new BGpio{tmp.release()};
+ }
+ return ret;
+}
+
+int BGpio_setDirection(const BGpio* gpio, int direction) {
+ android::GpioDirection dir;
+ if (!DirectionFromInt(direction, &dir))
+ return EINVAL;
+
+ return gpio->impl->SetDirection(dir);
+}
+
+int BGpio_setEdgeTriggerType(const BGpio* gpio, int type) {
+ android::GpioEdgeType t;
+ if (!EdgeTypeFromInt(type, &t))
+ return EINVAL;
+
+ return gpio->impl->SetEdgeTriggerType(t);
+}
+
+int BGpio_setActiveType(const BGpio* gpio, int type) {
+ android::GpioActiveType t;
+ if (!ActiveTypeFromInt(type, &t))
+ return EINVAL;
+
+ return gpio->impl->SetActiveType(t);
+}
+
+int BGpio_setValue(const BGpio* gpio, int value) {
+ return gpio->impl->SetValue(value);
+}
+
+int BGpio_getValue(const BGpio* gpio, int* value) {
+ return gpio->impl->GetValue(value);
+}
+
+int BGpio_getPollingFd(const BGpio* gpio, int* fd) {
+ return gpio->impl->GetPollingFd(fd);
+}
+
+int BGpio_ackInterruptEvent(int fd) {
+ uint8_t buf[2];
+ lseek(fd, 0, SEEK_SET);
+ read(fd, buf, 2);
+ return 0;
+}
+
+void BGpio_delete(BGpio* gpio) {
+ delete gpio->impl;
+ delete gpio;
+}
+
+// SPI API
+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;
+ 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) {
+ return device->impl->WriteByte(val);
+}
+
+int BSpiDevice_writeBuffer(const BSpiDevice* device,
+ const void* data,
+ size_t len) {
+ return device->impl->WriteBuffer(static_cast<const uint8_t*>(data), len);
+}
+
+int BSpiDevice_transfer(const BSpiDevice* device,
+ const void* tx_data,
+ void* rx_data,
+ size_t len) {
+ return device->impl->Transfer(static_cast<const uint8_t*>(tx_data),
+ static_cast<uint8_t*>(rx_data), len);
+}
+
+int BSpiDevice_setFrequency(const BSpiDevice* device, uint32_t freq_hz) {
+ return device->impl->SetFrequency(freq_hz);
+}
+
+int BSpiDevice_setMode(const BSpiDevice* device, int mode) {
+ if (mode == SPI_MODE0 || mode == SPI_MODE1 || mode == SPI_MODE2 ||
+ mode == SPI_MODE3) {
+ return device->impl->SetMode(mode);
+ }
+ return EINVAL;
+}
+
+int BSpiDevice_setBitJustification(const BSpiDevice* device,
+ int bit_justification) {
+ if (bit_justification == SPI_LSB_FIRST ||
+ bit_justification == SPI_MSB_FIRST) {
+ return device->impl->SetBitJustification(bit_justification);
+ }
+ return EINVAL;
+}
+
+int BSpiDevice_setBitsPerWord(const BSpiDevice* device, uint8_t bits_per_word) {
+ return device->impl->SetBitsPerWord(bits_per_word);
+}
+
+int BSpiDevice_setDelay(const BSpiDevice* device, uint16_t delay_usecs) {
+ return device->impl->SetDelay(delay_usecs);
+}
+
+void BSpiDevice_delete(BSpiDevice* device) {
+ delete device->impl;
+ delete device;
+}
+
+char** BPeripheralManagerClient_listLeds(const BPeripheralManagerClient* client,
+ int* num_leds) {
+ std::vector<std::string> list;
+ client->impl->ListLeds(&list);
+ *num_leds = list.size();
+ return ConvertStringVectorToC(list);
+}
+
+int BPeripheralManagerClient_openLed(const BPeripheralManagerClient* client,
+ const char* name,
+ BLed** led) {
+ std::unique_ptr<LedImpl> impl;
+ int ret = client->impl->OpenLed(name, &impl);
+ if (!ret)
+ *led = new BLed{impl.release()};
+
+ return ret;
+}
+
+int BLed_setBrightness(const BLed* led, uint32_t brightness) {
+ return led->impl->SetBrightness(brightness);
+}
+
+int BLed_getBrightness(const BLed* led, uint32_t* brightness) {
+ return led->impl->GetBrightness(brightness);
+}
+
+int BLed_getMaxBrightness(const BLed* led, uint32_t* max_brightness) {
+ return led->impl->GetMaxBrightness(max_brightness);
+}
+
+void BLed_delete(BLed* led) {
+ delete led->impl;
+ delete led;
+}
+
+// I2C API
+char** BPeripheralManagerClient_listI2cBuses(
+ const BPeripheralManagerClient* client, int* num_i2c_buses) {
+ std::vector<std::string> list;
+ client->impl->ListI2cBuses(&list);
+ *num_i2c_buses = list.size();
+ return ConvertStringVectorToC(list);
+}
+
+int BPeripheralManagerClient_openI2cDevice(
+ const BPeripheralManagerClient* client,
+ const char* name,
+ uint32_t address,
+ BI2cDevice** dev) {
+ std::unique_ptr<I2cDeviceImpl> impl;
+ int ret = client->impl->OpenI2cDevice(name, address, &impl);
+ if (ret == 0) {
+ *dev = new BI2cDevice{impl.release()};
+ }
+
+ return ret;
+}
+
+int BI2cDevice_read(const BI2cDevice* device,
+ void* data,
+ uint32_t len,
+ uint32_t* bytes_read) {
+ return device->impl->Read(data, len, bytes_read);
+}
+
+int BI2cDevice_readRegByte(const BI2cDevice* device,
+ uint8_t reg,
+ uint8_t* val) {
+ return device->impl->ReadRegByte(reg, val);
+}
+
+int BI2cDevice_readRegWord(const BI2cDevice* device,
+ uint8_t reg,
+ uint16_t* val) {
+ return device->impl->ReadRegWord(reg, val);
+}
+
+int BI2cDevice_readRegBuffer(const BI2cDevice* device,
+ uint8_t reg,
+ void* data,
+ uint32_t len,
+ uint32_t* bytes_read) {
+ return device->impl->ReadRegBuffer(reg, data, len, bytes_read);
+}
+
+int BI2cDevice_write(const BI2cDevice* device,
+ const void* data,
+ uint32_t len,
+ uint32_t* bytes_written) {
+ return device->impl->Write(data, len, bytes_written);
+}
+
+int BI2cDevice_writeRegByte(const BI2cDevice* device,
+ uint8_t reg,
+ uint8_t val) {
+ return device->impl->WriteRegByte(reg, val);
+}
+
+int BI2cDevice_writeRegWord(const BI2cDevice* device,
+ uint8_t reg,
+ uint16_t val) {
+ return device->impl->WriteRegWord(reg, val);
+}
+
+int BI2cDevice_writeRegBuffer(const BI2cDevice* device,
+ uint8_t reg,
+ const void* data,
+ uint32_t len,
+ uint32_t* bytes_written) {
+ return device->impl->WriteRegBuffer(reg, data, len, bytes_written);
+}
+
+void BI2cDevice_delete(BI2cDevice* device) {
+ delete device->impl;
+ delete device;
+}
+
+char** BPeripheralManagerClient_listUartDevices(
+ const BPeripheralManagerClient* client, int* num_uart_devices) {
+ std::vector<std::string> list;
+ client->impl->ListUartDevices(&list);
+ *num_uart_devices = list.size();
+ return ConvertStringVectorToC(list);
+}
+
+int BPeripheralManagerClient_openUartDevice(
+ const BPeripheralManagerClient* client,
+ const char* name,
+ BUartDevice** device) {
+ std::unique_ptr<UartDeviceImpl> impl;
+ int ret = client->impl->OpenUartDevice(name, &impl);
+ if (ret == 0) {
+ *device = new BUartDevice{impl.release()};
+ }
+ return ret;
+}
+
+int BUartDevice_setBaudrate(const BUartDevice* device, uint32_t baudrate) {
+ return device->impl->SetBaudrate(baudrate);
+}
+
+int BUartDevice_write(const BUartDevice* device,
+ const void* data,
+ uint32_t size,
+ uint32_t* bytes_written) {
+ return device->impl->Write(data, size, bytes_written);
+}
+
+int BUartDevice_read(const BUartDevice* device,
+ void* data,
+ uint32_t size,
+ uint32_t* bytes_read) {
+ return device->impl->Read(data, size, bytes_read);
+}
+
+void BUartDevice_delete(BUartDevice* device) {
+ delete device->impl;
+ delete device;
+}
diff --git a/peripheralmanager/common/peripheralmanager/constants.h b/peripheralmanager/common/peripheralmanager/constants.h
new file mode 100644
index 0000000..d30a28f
--- /dev/null
+++ b/peripheralmanager/common/peripheralmanager/constants.h
@@ -0,0 +1,50 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_PERIPHERALMANAGER_CONSTANTS_H_
+#define SYSTEM_PERIPHERALMANAGER_PERIPHERALMANAGER_CONSTANTS_H_
+
+namespace android {
+
+enum GpioEdgeType {
+ kEdgeNone,
+ kEdgeRising,
+ kEdgeFalling,
+ kEdgeBoth,
+};
+
+enum GpioDirection {
+ kDirectionIn,
+ kDirectionOutInitiallyHigh,
+ kDirectionOutInitiallyLow,
+};
+
+enum GpioActiveType {
+ kActiveLow,
+ kActiveHigh,
+};
+
+// The SPI modes are the same as the ones defined by the linux kernel.
+enum SpiMode {
+ kMode0,
+ kMode1,
+ kMode2,
+ kMode3,
+};
+
+} // namespace android
+
+#endif // SYSTEM_PERIPHERALMANAGER_PERIPHERALMANAGER_CONSTANTS_H_
diff --git a/peripheralmanager/daemon/Android.mk b/peripheralmanager/daemon/Android.mk
new file mode 100644
index 0000000..935ee62
--- /dev/null
+++ b/peripheralmanager/daemon/Android.mk
@@ -0,0 +1,141 @@
+#
+# Copyright (C) 2015 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.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+peripheralman_CommonCFlags := -Wall -Werror -Wno-unused-parameter
+peripheralman_CommonCFlags += -Wno-sign-promo # for libchrome
+peripheralman_CommonCIncludes := \
+ $(LOCAL_PATH)/../common \
+ $(LOCAL_PATH)/../include \
+ external/gtest/include \
+
+peripheralman_CommonSharedLibraries := \
+ libbinder \
+ libbinderwrapper \
+ libchrome \
+ libutils \
+ libhardware \
+
+libperipheralman_internal_CommonSources := \
+ char_device.cc \
+ gpio_driver_sysfs.cc \
+ gpio_manager.cc \
+ i2c_driver_i2cdev.cc \
+ i2c_manager.cc \
+ led_driver_sysfs.cc \
+ led_manager.cc \
+ peripheral_manager.cc \
+ peripheral_manager_client.cc \
+ pin_mux_manager.cc \
+ spi_driver_spidev.cc \
+ spi_manager.cc \
+ uart_driver_sysfs.cc \
+ uart_manager.cc \
+
+# peripheralman executable
+# ========================================================
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := peripheralman
+LOCAL_REQUIRED_MODULES := peripheralman.rc
+LOCAL_CPP_EXTENSION := .cc
+LOCAL_CFLAGS := $(peripheralman_CommonCFlags)
+LOCAL_C_INCLUDES := $(peripheralman_CommonCIncludes)
+
+LOCAL_STATIC_LIBRARIES := \
+ libperipheralman_internal \
+ libperipheralman_binder \
+ peripheral_manager_hal_headers \
+
+LOCAL_SHARED_LIBRARIES := \
+ $(peripheralman_CommonSharedLibraries) \
+ libbrillo \
+ libbrillo-binder \
+
+LOCAL_SRC_FILES := main.cc
+LOCAL_INIT_RC := peripheralman.rc
+include $(BUILD_EXECUTABLE)
+
+# libperipheralman_internal static lib
+# ========================================================
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := libperipheralman_internal
+LOCAL_CPP_EXTENSION := .cc
+LOCAL_CFLAGS := $(peripheralman_CommonCFlags)
+LOCAL_C_INCLUDES := $(peripheralman_CommonCIncludes)
+LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/../include
+LOCAL_STATIC_LIBRARIES := \
+ libperipheralman_binder \
+ peripheral_manager_hal_headers \
+
+LOCAL_SHARED_LIBRARIES := \
+ $(peripheralman_CommonSharedLibraries) \
+
+LOCAL_SRC_FILES := $(libperipheralman_internal_CommonSources)
+include $(BUILD_STATIC_LIBRARY)
+
+# libperipheral_internal_test static lib used to test the client.
+# ===============================================================
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := libperipheralman_internal_test
+LOCAL_CPP_EXTENSION := .cc
+LOCAL_CFLAGS := $(peripheralman_CommonCFlags)
+LOCAL_C_INCLUDES := $(peripheralman_CommonCIncludes)
+LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/../include \
+ $(LOCAL_PATH) \
+ $(LOCAL_PATH)/../hal \
+
+LOCAL_STATIC_LIBRARIES := \
+ libperipheralman_binder \
+ peripheral_manager_hal_headers \
+
+LOCAL_SHARED_LIBRARIES := \
+ libbinder \
+ libbinderwrapper_test_support \
+ libchrome \
+ libutils \
+ libhardware \
+
+LOCAL_SRC_FILES := $(libperipheralman_internal_CommonSources) \
+ fake_devices.cc \
+ fake_i2c_devices.cc \
+
+include $(BUILD_STATIC_LIBRARY)
+
+# peripheralman unit tests
+# ========================================================
+include $(CLEAR_VARS)
+LOCAL_MODULE := peripheralman_unittests
+LOCAL_CPP_EXTENSION := .cc
+LOCAL_CFLAGS := $(peripheralman_CommonCFlags)
+LOCAL_C_INCLUDES := $(peripheralman_CommonCIncludes)
+LOCAL_STATIC_LIBRARIES := libperipheralman_internal \
+ peripheral_manager_hal_headers \
+
+LOCAL_SHARED_LIBRARIES := \
+ libchrome \
+
+LOCAL_SRC_FILES := \
+ fake_devices.cc \
+ fake_i2c_devices.cc \
+ gpio_manager_unittest.cc \
+ pin_mux_manager_unittest.cc \
+ spi_manager_unittest.cc \
+
+include $(BUILD_NATIVE_TEST)
diff --git a/peripheralmanager/daemon/char_device.cc b/peripheralmanager/daemon/char_device.cc
new file mode 100644
index 0000000..720c439
--- /dev/null
+++ b/peripheralmanager/daemon/char_device.cc
@@ -0,0 +1,55 @@
+/*
+ * 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 "char_device.h"
+
+#include <fcntl.h>
+#include <poll.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+namespace android {
+
+CharDevice::CharDevice() {}
+CharDevice::~CharDevice() {}
+
+int CharDevice::Open(const char* pathname, int flags) {
+ return open(pathname, flags);
+}
+
+int CharDevice::Close(int fd) {
+ return close(fd);
+}
+
+int CharDevice::Ioctl(int fd, int request, void* argp) {
+ return ioctl(fd, request, argp);
+}
+
+ssize_t CharDevice::Read(int fd, void* buf, size_t count) {
+ return read(fd, buf, count);
+}
+
+ssize_t CharDevice::Write(int fd, const void* buf, size_t count) {
+ return write(fd, buf, count);
+}
+
+int CharDevice::Poll(struct pollfd* fds, nfds_t nfds, int timeout) {
+ return poll(fds, nfds, timeout);
+}
+
+} // namespace android
diff --git a/peripheralmanager/daemon/char_device.h b/peripheralmanager/daemon/char_device.h
new file mode 100644
index 0000000..53e6a3e
--- /dev/null
+++ b/peripheralmanager/daemon/char_device.h
@@ -0,0 +1,65 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_DAEMON_CHAR_DEVICE_H_
+#define SYSTEM_PERIPHERALMANAGER_DAEMON_CHAR_DEVICE_H_
+
+#include <poll.h>
+#include <stdlib.h>
+
+#include <memory>
+
+namespace android {
+
+// Used to wrap the interface to a char device file.
+// This can then be stubbed out and used in unittests.
+class CharDeviceInterface {
+ public:
+ CharDeviceInterface(){};
+ virtual ~CharDeviceInterface(){};
+
+ virtual int Open(const char* pathname, int flags) = 0;
+ virtual int Close(int fd) = 0;
+ virtual int Ioctl(int fd, int request, void* argp) = 0;
+ virtual ssize_t Read(int fd, void* buf, size_t count) = 0;
+ virtual ssize_t Write(int fd, const void* buf, size_t count) = 0;
+ virtual int Poll(struct pollfd* fds, nfds_t nfds, int timeout) = 0;
+};
+
+class CharDevice : public CharDeviceInterface {
+ public:
+ CharDevice();
+ ~CharDevice() override;
+
+ int Open(const char* pathname, int flags) override;
+ int Close(int fd) override;
+ int Ioctl(int fd, int request, void* argp) override;
+ ssize_t Read(int fd, void* buf, size_t count) override;
+ ssize_t Write(int fd, const void* buf, size_t count) override;
+ int Poll(struct pollfd* fds, nfds_t nfds, int timeout) override;
+};
+
+class CharDeviceFactory {
+ public:
+ CharDeviceFactory() {}
+ virtual ~CharDeviceFactory() {}
+
+ virtual std::unique_ptr<CharDeviceInterface> NewCharDevice() = 0;
+};
+
+} // namespace android
+
+#endif // SYSTEM_PERIPHERALMANAGER_DAEMON_CHAR_DEVICE_H_
\ No newline at end of file
diff --git a/peripheralmanager/daemon/fake_devices.cc b/peripheralmanager/daemon/fake_devices.cc
new file mode 100644
index 0000000..2555a95
--- /dev/null
+++ b/peripheralmanager/daemon/fake_devices.cc
@@ -0,0 +1,59 @@
+/*
+ * 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 "fake_devices.h"
+
+#include <stdio.h>
+
+namespace android {
+
+FakeCharDevice::FakeCharDevice() {}
+FakeCharDevice::~FakeCharDevice() {}
+
+// TODO(leecam): Implement these.
+int FakeCharDevice::Open(const char* pathname, int flags) {
+ return 1;
+}
+
+int FakeCharDevice::Close(int fd) {
+ return 0;
+}
+
+int FakeCharDevice::Ioctl(int fd, int request, void* argp) {
+ return 0;
+}
+
+ssize_t FakeCharDevice::Read(int fd, void* buf, size_t count) {
+ return count;
+}
+
+ssize_t FakeCharDevice::Write(int fd, const void* buf, size_t count) {
+ return count;
+}
+
+int FakeCharDevice::Poll(struct pollfd* fds, nfds_t nfds, int timeout) {
+ return 0;
+}
+
+FakeDeviceFactory::FakeDeviceFactory() {}
+
+FakeDeviceFactory::~FakeDeviceFactory() {}
+
+std::unique_ptr<CharDeviceInterface> FakeDeviceFactory::NewCharDevice() {
+ return std::unique_ptr<CharDeviceInterface>(new FakeCharDevice());
+}
+
+} // namespace android
diff --git a/peripheralmanager/daemon/fake_devices.h b/peripheralmanager/daemon/fake_devices.h
new file mode 100644
index 0000000..d1aa7f9
--- /dev/null
+++ b/peripheralmanager/daemon/fake_devices.h
@@ -0,0 +1,50 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_DAEMON_FAKE_DEVICES_H_
+#define SYSTEM_PERIPHERALMANAGER_DAEMON_FAKE_DEVICES_H_
+
+#include <string>
+#include <vector>
+
+#include "char_device.h"
+
+namespace android {
+
+class FakeCharDevice : public CharDeviceInterface {
+ public:
+ FakeCharDevice();
+ ~FakeCharDevice() override;
+
+ int Open(const char* pathname, int flags) override;
+ int Close(int fd) override;
+ int Ioctl(int fd, int request, void* argp) override;
+ ssize_t Read(int fd, void* buf, size_t count) override;
+ ssize_t Write(int fd, const void* buf, size_t count) override;
+ int Poll(struct pollfd* fds, nfds_t nfds, int timeout) override;
+};
+
+class FakeDeviceFactory : public CharDeviceFactory {
+ public:
+ FakeDeviceFactory();
+ ~FakeDeviceFactory();
+
+ std::unique_ptr<CharDeviceInterface> NewCharDevice() override;
+};
+
+} // namespace android
+
+#endif // SYSTEM_PERIPHERALMANAGER_DAEMON_FAKE_DEVICES_H_
diff --git a/peripheralmanager/daemon/fake_i2c_devices.cc b/peripheralmanager/daemon/fake_i2c_devices.cc
new file mode 100644
index 0000000..6cb7d8c
--- /dev/null
+++ b/peripheralmanager/daemon/fake_i2c_devices.cc
@@ -0,0 +1,103 @@
+/*
+ * 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 "fake_i2c_devices.h"
+
+#include <base/logging.h>
+#include <linux/i2c-dev.h>
+#include <linux/i2c.h>
+
+namespace android {
+
+FakeI2cDevice::FakeI2cDevice() {}
+FakeI2cDevice::~FakeI2cDevice() {}
+
+int FakeI2cDevice::Open(const char* pathname, int flags) {
+ return 1;
+}
+
+int FakeI2cDevice::Close(int fd) {
+ return 0;
+}
+
+int FakeI2cDevice::Ioctl(int fd, int request, void* argp) {
+ if (request == I2C_SMBUS) {
+ struct i2c_smbus_ioctl_data* smbus_args =
+ reinterpret_cast<struct i2c_smbus_ioctl_data*>(argp);
+
+ if (smbus_args->read_write == I2C_SMBUS_WRITE) {
+ uint8_t* data = smbus_args->data->block;
+ std::vector<uint8_t> temp;
+ if (smbus_args->size == I2C_SMBUS_I2C_BLOCK_DATA) {
+ temp.assign(data + 1, data + data[0] + 1);
+ } else if (smbus_args->size == I2C_SMBUS_WORD_DATA) {
+ temp.assign(data, data + 2);
+ } else if (smbus_args->size == I2C_SMBUS_BYTE_DATA) {
+ temp.assign(data, data + 1);
+ }
+
+ registers_.emplace(smbus_args->command, temp);
+ LOG(INFO) << "writing " << temp.size() << " elements in "
+ << smbus_args->command;
+ return 0;
+ } else if (smbus_args->read_write == I2C_SMBUS_READ) {
+ if (!registers_.count(smbus_args->command)) {
+ LOG(INFO) << "no such register";
+ return -1;
+ }
+ auto reg = registers_.find(smbus_args->command);
+ LOG(INFO) << "reading register " << smbus_args->command << " that has "
+ << reg->second.size() << " elements";
+
+ if (smbus_args->size == I2C_SMBUS_I2C_BLOCK_DATA) {
+ memcpy(smbus_args->data->block + 1,
+ reg->second.data(),
+ smbus_args->data->block[0]);
+ } else if (smbus_args->size == I2C_SMBUS_WORD_DATA) {
+ memcpy(smbus_args->data->block, reg->second.data(), 2);
+ } else if (smbus_args->size == I2C_SMBUS_BYTE_DATA) {
+ memcpy(smbus_args->data->block, reg->second.data(), 1);
+ }
+ return 0;
+ }
+ } else if (request == I2C_SLAVE) {
+ return 0;
+ }
+
+ return -1;
+}
+
+ssize_t FakeI2cDevice::Read(int fd, void* buf, size_t count) {
+ return count;
+}
+
+ssize_t FakeI2cDevice::Write(int fd, const void* buf, size_t count) {
+ return count;
+}
+
+int FakeI2cDevice::Poll(struct pollfd* fds, nfds_t nfds, int timeout) {
+ return 0;
+}
+
+FakeI2cDeviceFactory::FakeI2cDeviceFactory() {}
+
+FakeI2cDeviceFactory::~FakeI2cDeviceFactory() {}
+
+std::unique_ptr<CharDeviceInterface> FakeI2cDeviceFactory::NewCharDevice() {
+ return std::unique_ptr<CharDeviceInterface>(new FakeI2cDevice());
+}
+
+} // namespace android
diff --git a/peripheralmanager/daemon/fake_i2c_devices.h b/peripheralmanager/daemon/fake_i2c_devices.h
new file mode 100644
index 0000000..6072cef
--- /dev/null
+++ b/peripheralmanager/daemon/fake_i2c_devices.h
@@ -0,0 +1,54 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_DAEMON_FAKE_I2C_DEVICES_H_
+#define SYSTEM_PERIPHERALMANAGER_DAEMON_FAKE_I2C_DEVICES_H_
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "char_device.h"
+
+namespace android {
+
+class FakeI2cDevice : public CharDeviceInterface {
+ public:
+ FakeI2cDevice();
+ ~FakeI2cDevice() override;
+
+ int Open(const char* pathname, int flags) override;
+ int Close(int fd) override;
+ int Ioctl(int fd, int request, void* argp) override;
+ ssize_t Read(int fd, void* buf, size_t count) override;
+ ssize_t Write(int fd, const void* buf, size_t count) override;
+ int Poll(struct pollfd* fds, nfds_t nfds, int timeout) override;
+
+ private:
+ std::map<uint8_t, std::vector<uint8_t>> registers_;
+};
+
+class FakeI2cDeviceFactory : public CharDeviceFactory {
+ public:
+ FakeI2cDeviceFactory();
+ ~FakeI2cDeviceFactory();
+
+ std::unique_ptr<CharDeviceInterface> NewCharDevice() override;
+};
+
+} // namespace android
+
+#endif // SYSTEM_PERIPHERALMANAGER_DAEMON_FAKE_I2C_DEVICES_H_
diff --git a/peripheralmanager/daemon/gpio_driver.h b/peripheralmanager/daemon/gpio_driver.h
new file mode 100644
index 0000000..084c0f3
--- /dev/null
+++ b/peripheralmanager/daemon/gpio_driver.h
@@ -0,0 +1,78 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_DAEMON_GPIO_DRIVER_H_
+#define SYSTEM_PERIPHERALMANAGER_DAEMON_GPIO_DRIVER_H_
+
+#include <stdint.h>
+
+#include <memory>
+#include <string>
+
+#include <android-base/unique_fd.h>
+#include <base/macros.h>
+#include <peripheralmanager/constants.h>
+
+namespace android {
+
+// This interface must be implemented by all
+// Gpio drivers.
+class GpioDriverInterface {
+ public:
+ GpioDriverInterface() {}
+ virtual ~GpioDriverInterface() {}
+
+ // TODO(leecam): Init should have generic params.
+ virtual bool Init(uint32_t index) = 0;
+
+ virtual bool SetValue(bool val) = 0;
+ virtual bool GetValue(bool* val) = 0;
+ virtual bool SetActiveType(GpioActiveType type) = 0;
+ virtual bool SetDirection(GpioDirection direction) = 0;
+ virtual bool SetEdgeType(GpioEdgeType type) = 0;
+ virtual bool GetPollingFd(::android::base::unique_fd* fd) = 0;
+};
+
+// The following is driver boilerplate.
+// TODO(leecam): Abstract this into a seperate Driver class.
+class GpioDriverInfoBase {
+ public:
+ GpioDriverInfoBase() {}
+ virtual ~GpioDriverInfoBase() {}
+
+ virtual std::string Compat() = 0;
+ virtual std::unique_ptr<GpioDriverInterface> Probe() = 0;
+};
+
+template <class T, class PARAM>
+class GpioDriverInfo : public GpioDriverInfoBase {
+ public:
+ explicit GpioDriverInfo(PARAM param) : param_(param) {}
+ ~GpioDriverInfo() override {}
+
+ std::string Compat() override { return T::Compat(); }
+
+ std::unique_ptr<GpioDriverInterface> Probe() override {
+ return std::unique_ptr<GpioDriverInterface>(new T(param_));
+ }
+
+ private:
+ PARAM param_;
+};
+
+} // namespace android
+
+#endif // SYSTEM_PERIPHERALMANAGER_DAEMON_GPIO_DRIVER_H_
diff --git a/peripheralmanager/daemon/gpio_driver_mock.h b/peripheralmanager/daemon/gpio_driver_mock.h
new file mode 100644
index 0000000..f52b0f1
--- /dev/null
+++ b/peripheralmanager/daemon/gpio_driver_mock.h
@@ -0,0 +1,58 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_DAEMON_GPIO_DRIVER_MOCK_H_
+#define SYSTEM_PERIPHERALMANAGER_DAEMON_GPIO_DRIVER_MOCK_H_
+
+#include <stdint.h>
+
+#include <base/macros.h>
+#include <gmock/gmock.h>
+
+#include "gpio_driver.h"
+
+namespace android {
+
+class GpioDriverMock : public GpioDriverInterface {
+ public:
+ explicit GpioDriverMock(void* arg) : is_input(true) {}
+ ~GpioDriverMock() {}
+
+ static std::string Compat() { return "GPIOSYSFS"; }
+
+ bool Init(uint32_t index) { return true; }
+
+ bool SetValue(bool val) { return !is_input; };
+
+ bool GetValue(bool* val) { return true; };
+ bool SetActiveType(GpioActiveType type) { return true; };
+
+ bool SetDirection(GpioDirection direction) {
+ is_input = direction == kDirectionIn;
+ return true;
+ };
+
+ bool SetEdgeType(GpioEdgeType type) { return true; };
+ bool GetPollingFd(::android::base::unique_fd* fd) { return true; };
+
+ private:
+ bool is_input;
+ DISALLOW_COPY_AND_ASSIGN(GpioDriverMock);
+};
+
+} // namespace android
+
+#endif // SYSTEM_PERIPHERALMANAGER_DAEMON_GPIO_DRIVER_MOCK_H_
diff --git a/peripheralmanager/daemon/gpio_driver_sysfs.cc b/peripheralmanager/daemon/gpio_driver_sysfs.cc
new file mode 100644
index 0000000..b49c2ff
--- /dev/null
+++ b/peripheralmanager/daemon/gpio_driver_sysfs.cc
@@ -0,0 +1,221 @@
+/*
+ * 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_driver_sysfs.h"
+
+#include <fcntl.h>
+#include <string>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <base/logging.h>
+
+namespace android {
+namespace {
+
+// Path to sysfd gpio.
+const char kSysfsGpioPathPrefix[] = "/sys/class/gpio/gpio";
+
+// Path to export file.
+const char kSysfsGpioExportPath[] = "/sys/class/gpio/export";
+
+// Direction filename.
+const char kDirection[] = "direction";
+
+// Value filename.
+const char kValue[] = "value";
+
+// Active low filename.
+const char kActiveLowFile[] = "active_low";
+
+// Edge filename.
+const char kEdge[] = "edge";
+
+// Edge values.
+const char kEdgeNoneValue[] = "none";
+const char kEdgeRisingValue[] = "rising";
+const char kEdgeFallingValue[] = "falling";
+const char kEdgeBothValue[] = "both";
+
+// Direction values
+const char kDirHigh[] = "high";
+const char kDirLow[] = "low";
+const char kDirIn[] = "in";
+
+// Value values.
+const char kValueHigh[] = "1";
+const char kValueLow[] = "0";
+
+} // namespace
+
+GpioDriverSysfs::GpioDriverSysfs(void* arg) : fd_(-1) {}
+
+GpioDriverSysfs::~GpioDriverSysfs() {
+ if (fd_ >= 0) {
+ close(fd_);
+ }
+}
+
+bool GpioDriverSysfs::Init(uint32_t index) {
+ if (!ExportGpio(index)) {
+ LOG(WARNING) << "GpioDriverSysfs: Failed to export " << index;
+ return false;
+ }
+ std::string path = kSysfsGpioPathPrefix + std::to_string(index);
+
+ int fd = open(path.c_str(), O_RDONLY);
+ if (fd < 0) {
+ PLOG(WARNING) << "Failed to open " << path;
+ return false;
+ }
+
+ fd_ = fd;
+ return true;
+}
+
+bool GpioDriverSysfs::SetValue(bool val) {
+ bool success = val ? Enable() : Disable();
+ if (!success) {
+ LOG(WARNING) << "Failed to set the value of the GPIO. Is it configured as "
+ << "output?";
+ }
+ return success;
+}
+
+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
+ *val = false;
+ return true;
+}
+
+bool GpioDriverSysfs::SetDirection(GpioDirection direction) {
+ switch (direction) {
+ case kDirectionIn:
+ return WriteToFile(kDirection, kDirIn);
+ case kDirectionOutInitiallyHigh:
+ return WriteToFile(kDirection, kDirHigh);
+ case kDirectionOutInitiallyLow:
+ return WriteToFile(kDirection, kDirLow);
+ }
+ return false;
+}
+
+bool GpioDriverSysfs::SetActiveType(GpioActiveType type) {
+ if (type == kActiveLow) {
+ return WriteToFile(kActiveLowFile, kValueLow);
+ } else if (type == kActiveHigh) {
+ return WriteToFile(kActiveLowFile, kValueHigh);
+ }
+ return false;
+}
+
+bool GpioDriverSysfs::SetEdgeType(GpioEdgeType type) {
+ switch (type) {
+ case kEdgeNone:
+ return WriteToFile(kEdge, kEdgeNoneValue);
+ case kEdgeRising:
+ return WriteToFile(kEdge, kEdgeRisingValue);
+ case kEdgeFalling:
+ return WriteToFile(kEdge, kEdgeFallingValue);
+ case kEdgeBoth:
+ return WriteToFile(kEdge, kEdgeBothValue);
+ }
+ return false;
+}
+
+bool GpioDriverSysfs::GetPollingFd(::android::base::unique_fd* fd) {
+ int f = openat(fd_, kValue, O_RDWR);
+ if (f < 0)
+ return false;
+
+ fd->reset(f);
+ return true;
+}
+
+bool GpioDriverSysfs::Enable() {
+ return WriteToFile(kValue, kValueHigh);
+}
+
+bool GpioDriverSysfs::Disable() {
+ return WriteToFile(kValue, kValueLow);
+}
+
+bool GpioDriverSysfs::WriteToFile(const std::string& file,
+ const std::string& value) {
+ int fd = openat(fd_, file.c_str(), O_RDWR);
+ if (fd < 0)
+ return false;
+
+ ssize_t bytes = write(fd, value.c_str(), value.size());
+ close(fd);
+ if (bytes < 0)
+ return false;
+ if ((size_t)bytes != value.size())
+ return false;
+ return true;
+}
+
+bool GpioDriverSysfs::ReadFromFile(const std::string& file,
+ std::string* value) {
+ int fd = openat(fd_, file.c_str(), O_RDONLY);
+ if (fd < 0)
+ return false;
+ char tmp_buf[16] = "";
+ ssize_t bytes = read(fd, tmp_buf, sizeof(tmp_buf));
+ close(fd);
+ if (bytes < 0)
+ return false;
+ value->assign(tmp_buf, bytes);
+ return true;
+}
+
+bool GpioDriverSysfs::ExportGpio(uint32_t index) {
+ // Check if the pin is already exported.
+ // It will fail otherwise.
+ std::string path = kSysfsGpioPathPrefix + std::to_string(index);
+ struct stat stat_buf;
+ if (!stat(path.c_str(), &stat_buf))
+ return true;
+
+ int fd = open(kSysfsGpioExportPath, O_WRONLY);
+ if (fd < 0) {
+ PLOG(WARNING) << "Failed to open " << kSysfsGpioExportPath;
+ return false;
+ }
+ std::string value = std::to_string(index);
+ ssize_t bytes = write(fd, value.c_str(), value.size());
+ close(fd);
+ if (bytes < 0) {
+ PLOG(WARNING) << "Failed to write " << bytes;
+ return false;
+ }
+ if ((size_t)bytes != value.size())
+ return false;
+ return true;
+}
+
+} // namespace android
diff --git a/peripheralmanager/daemon/gpio_driver_sysfs.h b/peripheralmanager/daemon/gpio_driver_sysfs.h
new file mode 100644
index 0000000..690066a
--- /dev/null
+++ b/peripheralmanager/daemon/gpio_driver_sysfs.h
@@ -0,0 +1,59 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_DAEMON_GPIO_DRIVER_SYSFS_H_
+#define SYSTEM_PERIPHERALMANAGER_DAEMON_GPIO_DRIVER_SYSFS_H_
+
+#include <stdint.h>
+
+#include <base/macros.h>
+
+#include "gpio_driver.h"
+
+namespace android {
+
+class GpioDriverSysfs : public GpioDriverInterface {
+ public:
+ explicit GpioDriverSysfs(void* arg);
+ ~GpioDriverSysfs();
+
+ static std::string Compat() { return "GPIOSYSFS"; }
+
+ bool Init(uint32_t index) override;
+
+ // Gpio Driver interface.
+ bool SetValue(bool val) override;
+ bool GetValue(bool* val) override;
+ bool SetActiveType(GpioActiveType type) override;
+ bool SetDirection(GpioDirection direction) override;
+ bool SetEdgeType(GpioEdgeType type) override;
+ bool GetPollingFd(::android::base::unique_fd* fd) override;
+
+ private:
+ bool Enable();
+ bool Disable();
+ bool ExportGpio(uint32_t index);
+ bool WriteToFile(const std::string& file, const std::string& value);
+ bool ReadFromFile(const std::string& file, std::string* value);
+
+ int fd_;
+
+ DISALLOW_COPY_AND_ASSIGN(GpioDriverSysfs);
+};
+
+} // namespace android
+
+#endif // SYSTEM_PERIPHERALMANAGER_DAEMON_GPIO_DRIVER_SYSFS_H_
diff --git a/peripheralmanager/daemon/gpio_manager.cc b/peripheralmanager/daemon/gpio_manager.cc
new file mode 100644
index 0000000..1a47941
--- /dev/null
+++ b/peripheralmanager/daemon/gpio_manager.cc
@@ -0,0 +1,114 @@
+/*
+ * 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_manager.h"
+
+#include <base/logging.h>
+
+namespace android {
+
+std::unique_ptr<GpioManager> g_gpio_manager;
+
+GpioManager::GpioManager() {}
+
+GpioManager::~GpioManager() {}
+
+// static
+GpioManager* GpioManager::GetGpioManager() {
+ if (!g_gpio_manager) {
+ g_gpio_manager.reset(new GpioManager());
+ }
+ return g_gpio_manager.get();
+}
+
+void GpioManager::ResetGpioManager() {
+ g_gpio_manager.reset();
+}
+
+bool GpioManager::RegisterGpioSysfs(const std::string& name, uint32_t index) {
+ if (sysfs_pins_.count(name))
+ return false;
+ sysfs_pins_[name].index = index;
+ return true;
+}
+
+bool GpioManager::SetPinMux(const std::string& name, const std::string& mux) {
+ if (!sysfs_pins_.count(name))
+ return false;
+ sysfs_pins_[name].mux = mux;
+ return true;
+}
+
+std::vector<std::string> GpioManager::GetGpioPins() {
+ std::vector<std::string> pins;
+ for (auto& i : sysfs_pins_)
+ pins.push_back(i.first);
+ return pins;
+}
+
+bool GpioManager::HasGpio(const std::string& pin_name) {
+ return sysfs_pins_.count(pin_name);
+}
+
+bool GpioManager::RegisterDriver(
+ std::unique_ptr<GpioDriverInfoBase> driver_info) {
+ std::string key = driver_info->Compat();
+ driver_infos_[key] = std::move(driver_info);
+ return true;
+}
+
+std::unique_ptr<GpioPin> GpioManager::OpenGpioPin(const std::string& name) {
+ // Get the Pin from the BSP.
+ auto pin_it = sysfs_pins_.find(name);
+ if (pin_it == sysfs_pins_.end()) {
+ LOG(WARNING) << "GpioManager: Pin not found. " << name;
+ return nullptr;
+ }
+
+ // Check its not alread in use
+ if (pin_it->second.driver_) {
+ LOG(WARNING) << "GpioManager: Pin in use. " << name;
+ return nullptr;
+ }
+
+ // Find a driver.
+ // Currently there is only hardcoded support for GPIOSYSFS
+ auto driver_info_it = driver_infos_.find("GPIOSYSFS");
+
+ // Fail if there is no driver.
+ if (driver_info_it == driver_infos_.end()) {
+ LOG(WARNING) << "GpioManager: Failed to find driver " << name;
+ return nullptr;
+ }
+
+ std::unique_ptr<GpioDriverInterface> driver(driver_info_it->second->Probe());
+
+ // Set pin mux
+ if (!pin_it->second.mux.empty()) {
+ PinMuxManager::GetPinMuxManager()->SetGpio(pin_it->second.mux);
+ }
+
+ if (!driver->Init(pin_it->second.index)) {
+ LOG(WARNING) << "GpioManager: Failed to init driver " << name;
+ return nullptr;
+ }
+
+ pin_it->second.driver_ = std::move(driver);
+
+ return std::unique_ptr<GpioPin>(new GpioPin(&(pin_it->second)));
+}
+
+} // namespace android
diff --git a/peripheralmanager/daemon/gpio_manager.h b/peripheralmanager/daemon/gpio_manager.h
new file mode 100644
index 0000000..52bd779
--- /dev/null
+++ b/peripheralmanager/daemon/gpio_manager.h
@@ -0,0 +1,119 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_DAEMON_GPIO_MANAGER_H_
+#define SYSTEM_PERIPHERALMANAGER_DAEMON_GPIO_MANAGER_H_
+
+#include <stdint.h>
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <base/macros.h>
+
+#include "gpio_driver.h"
+#include "pin_mux_manager.h"
+
+namespace android {
+
+struct GpioPinSysfs {
+ uint32_t index;
+ std::string mux;
+ std::unique_ptr<GpioDriverInterface> driver_;
+};
+
+class GpioPin {
+ public:
+ // TODO(leecam): pins should have a generic device
+ // reference, not a sysfs one.
+ explicit GpioPin(GpioPinSysfs* pin) : pin_(pin) {}
+ ~GpioPin() {
+ if (!pin_->mux.empty()) {
+ PinMuxManager::GetPinMuxManager()->ReleaseGpio(pin_->mux);
+ }
+ pin_->driver_.reset();
+ }
+
+ bool SetValue(bool val) { return pin_->driver_->SetValue(val); }
+
+ bool GetValue(bool* val) { return pin_->driver_->GetValue(val); }
+
+ bool SetDirection(GpioDirection direction) {
+ if (!pin_->mux.empty()) {
+ bool dir = true;
+ if (direction == kDirectionIn)
+ dir = false;
+ if (!PinMuxManager::GetPinMuxManager()->SetGpioDirection(pin_->mux,
+ dir)) {
+ return false;
+ }
+ }
+ return pin_->driver_->SetDirection(direction);
+ }
+
+ bool SetActiveType(GpioActiveType type) {
+ return pin_->driver_->SetActiveType(type);
+ }
+
+ bool SetEdgeType(GpioEdgeType type) {
+ return pin_->driver_->SetEdgeType(type);
+ }
+
+ bool GetPollingFd(::android::base::unique_fd* fd) {
+ return pin_->driver_->GetPollingFd(fd);
+ }
+
+ private:
+ GpioPinSysfs* pin_;
+};
+
+class GpioManager {
+ public:
+ friend class GpioManagerTest;
+ ~GpioManager();
+
+ // Get the singleton.
+ static GpioManager* GetGpioManager();
+
+ // Delete the GpioManager (used for test);
+ static void ResetGpioManager();
+
+ // Used by the BSP to tell PMan of an GPIO Pin.
+ bool RegisterGpioSysfs(const std::string& name, uint32_t index);
+ bool SetPinMux(const std::string& name, const std::string& mux);
+
+ // Query for available pins.
+ std::vector<std::string> GetGpioPins();
+ bool HasGpio(const std::string& pin_name);
+
+ bool RegisterDriver(std::unique_ptr<GpioDriverInfoBase> driver_info);
+
+ std::unique_ptr<GpioPin> OpenGpioPin(const std::string& name);
+
+ private:
+ GpioManager();
+
+ std::map<std::string, std::unique_ptr<GpioDriverInfoBase>> driver_infos_;
+ std::map<std::string, GpioPinSysfs> sysfs_pins_;
+
+ DISALLOW_COPY_AND_ASSIGN(GpioManager);
+};
+
+} // namespace android
+
+#endif // SYSTEM_PERIPHERALMANAGER_DAEMON_GPIO_MANAGER_H_
diff --git a/peripheralmanager/daemon/gpio_manager_unittest.cc b/peripheralmanager/daemon/gpio_manager_unittest.cc
new file mode 100644
index 0000000..0e7b07b
--- /dev/null
+++ b/peripheralmanager/daemon/gpio_manager_unittest.cc
@@ -0,0 +1,52 @@
+/*
+ * 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 <stdio.h>
+
+#include <gtest/gtest.h>
+
+#include "gpio_driver_sysfs.h"
+#include "gpio_manager.h"
+
+namespace android {
+
+class GpioManagerTest : public ::testing::Test {
+ public:
+ GpioManagerTest() {}
+ ~GpioManagerTest() = default;
+
+ protected:
+ GpioManager manager;
+};
+
+TEST_F(GpioManagerTest, RegisterDriver) {
+ manager.RegisterDriver(std::unique_ptr<GpioDriverInfoBase>(
+ new GpioDriverInfo<GpioDriverSysfs, void*>(nullptr)));
+}
+
+TEST_F(GpioManagerTest, BasicOpen) {
+ manager.RegisterDriver(std::unique_ptr<GpioDriverInfoBase>(
+ new GpioDriverInfo<GpioDriverSysfs, void*>(nullptr)));
+
+ manager.RegisterGpioSysfs("IO11", 40);
+
+ std::unique_ptr<GpioPin> pin(manager.OpenGpioPin("IO11"));
+}
+
+// TODO(leecam): Once this stablizes and has a stub,
+// write lots more tests.
+
+} // namespace android
\ No newline at end of file
diff --git a/peripheralmanager/daemon/i2c_driver.h b/peripheralmanager/daemon/i2c_driver.h
new file mode 100644
index 0000000..7eac065
--- /dev/null
+++ b/peripheralmanager/daemon/i2c_driver.h
@@ -0,0 +1,86 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_DAEMON_I2C_DRIVER_H_
+#define SYSTEM_PERIPHERALMANAGER_DAEMON_I2C_DRIVER_H_
+
+#include <stdint.h>
+
+#include <memory>
+#include <string>
+
+#include <base/macros.h>
+
+#include "peripheralmanager/constants.h"
+
+namespace android {
+
+class I2cDriverInterface {
+ public:
+ I2cDriverInterface() {}
+ virtual ~I2cDriverInterface() {}
+
+ // TODO(leecam): Init should have generic params.
+ virtual bool Init(uint32_t bus_id, uint32_t address) = 0;
+
+ // Returns 0 on success, errno on errors.
+ virtual int32_t Read(void* data, uint32_t size, uint32_t* bytes_read) = 0;
+ virtual int32_t ReadRegByte(uint8_t reg, uint8_t* val) = 0;
+ virtual int32_t ReadRegWord(uint8_t reg, uint16_t* val) = 0;
+ virtual int32_t ReadRegBuffer(uint8_t reg,
+ uint8_t* data,
+ uint32_t size,
+ uint32_t* bytes_read) = 0;
+
+ virtual int32_t Write(const void* data,
+ uint32_t size,
+ uint32_t* bytes_written) = 0;
+ virtual int32_t WriteRegByte(uint8_t reg, uint8_t val) = 0;
+ virtual int32_t WriteRegWord(uint8_t reg, uint16_t val) = 0;
+ virtual int32_t WriteRegBuffer(uint8_t reg,
+ const uint8_t* data,
+ uint32_t size,
+ uint32_t* bytes_written) = 0;
+};
+
+class I2cDriverInfoBase {
+ public:
+ I2cDriverInfoBase() {}
+ virtual ~I2cDriverInfoBase() {}
+
+ virtual std::string Compat() = 0;
+ virtual std::unique_ptr<I2cDriverInterface> Probe() = 0;
+};
+
+template <class T, class PARAM>
+class I2cDriverInfo : public I2cDriverInfoBase {
+ public:
+ explicit I2cDriverInfo(PARAM param) : param_(param) {}
+ ~I2cDriverInfo() override {}
+
+ std::string Compat() override { return T::Compat(); }
+
+ std::unique_ptr<I2cDriverInterface> Probe() override {
+ return std::unique_ptr<I2cDriverInterface>(new T(param_));
+ }
+
+ private:
+ PARAM param_;
+};
+
+} // namespace android
+
+#endif // SYSTEM_PERIPHERALMANAGER_DAEMON_I2C_DRIVER_H_
diff --git a/peripheralmanager/daemon/i2c_driver_i2cdev.cc b/peripheralmanager/daemon/i2c_driver_i2cdev.cc
new file mode 100644
index 0000000..b4f2280
--- /dev/null
+++ b/peripheralmanager/daemon/i2c_driver_i2cdev.cc
@@ -0,0 +1,207 @@
+/*
+ * 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 "i2c_driver_i2cdev.h"
+
+#include <fcntl.h>
+#include <linux/i2c.h>
+#include <linux/i2c-dev.h>
+#include <sys/ioctl.h>
+#include <string>
+
+#include <base/logging.h>
+
+namespace android {
+namespace {
+
+const char kI2cDevPath[] = "/dev/i2c-";
+
+} // namespace
+
+I2cDriverI2cDev::I2cDriverI2cDev(CharDeviceFactory* char_device_factory)
+ : fd_(-1), char_device_factory_(char_device_factory) {}
+
+I2cDriverI2cDev::~I2cDriverI2cDev() {
+ if (fd_ >= 0 && char_interface_ != nullptr) {
+ char_interface_->Close(fd_);
+ }
+}
+
+bool I2cDriverI2cDev::Init(uint32_t bus_id, uint32_t address) {
+ if (fd_ >= 0) {
+ return false;
+ }
+ // Get a char device. If char_device_factory_ is set
+ // then this is a unittest and the char device is provided
+ // by the test. Otherwise create a normal CharDevice.
+ if (!char_device_factory_) {
+ char_interface_.reset(new CharDevice());
+ } else {
+ char_interface_ = char_device_factory_->NewCharDevice();
+ }
+
+ std::string path = kI2cDevPath + std::to_string(bus_id);
+
+ int fd = char_interface_->Open(path.c_str(), O_RDWR);
+ if (fd < 0)
+ return false;
+ uintptr_t tmp_addr = address;
+ if (char_interface_->Ioctl(fd, I2C_SLAVE, (void*)tmp_addr) < 0) {
+ LOG(ERROR) << "Failed to set I2C slave";
+ char_interface_->Close(fd);
+ return false;
+ }
+
+ fd_ = fd;
+
+ return true;
+}
+
+int32_t I2cDriverI2cDev::Read(void* data, uint32_t size, uint32_t* bytes_read) {
+ *bytes_read = char_interface_->Read(fd_, data, size);
+ return *bytes_read == size ? 0 : EIO;
+}
+
+int32_t I2cDriverI2cDev::ReadRegByte(uint8_t reg, uint8_t* val) {
+ union i2c_smbus_data read_data;
+ struct i2c_smbus_ioctl_data smbus_args {
+ .command = reg, .read_write = I2C_SMBUS_READ, .size = I2C_SMBUS_BYTE_DATA,
+ .data = &read_data,
+ };
+
+ if (char_interface_->Ioctl(fd_, I2C_SMBUS, &smbus_args) < 0) {
+ LOG(INFO) << "Failed I2C_SMBUS";
+ return EIO;
+ }
+
+ *val = read_data.byte;
+ return 0;
+}
+
+int32_t I2cDriverI2cDev::ReadRegWord(uint8_t reg, uint16_t* val) {
+ union i2c_smbus_data read_data;
+ struct i2c_smbus_ioctl_data smbus_args {
+ .command = reg, .read_write = I2C_SMBUS_READ, .size = I2C_SMBUS_WORD_DATA,
+ .data = &read_data,
+ };
+
+ if (char_interface_->Ioctl(fd_, I2C_SMBUS, &smbus_args) < 0) {
+ LOG(INFO) << "Failed I2C_SMBUS";
+ return EIO;
+ }
+
+ *val = read_data.word;
+ return 0;
+}
+
+int32_t I2cDriverI2cDev::ReadRegBuffer(uint8_t reg,
+ uint8_t* data,
+ uint32_t size,
+ uint32_t* bytes_read) {
+ *bytes_read = 0;
+ if (size > I2C_SMBUS_BLOCK_MAX) {
+ LOG(WARNING) << "Can't read more than 32 bytes at a time.";
+ return EINVAL;
+ }
+
+ union i2c_smbus_data read_data;
+ read_data.block[0] = size;
+
+ struct i2c_smbus_ioctl_data smbus_args;
+ smbus_args.command = reg;
+ smbus_args.read_write = I2C_SMBUS_READ;
+ smbus_args.size = I2C_SMBUS_I2C_BLOCK_DATA;
+ smbus_args.data = &read_data;
+
+ if (char_interface_->Ioctl(fd_, I2C_SMBUS, &smbus_args) < 0) {
+ LOG(ERROR) << "Failed I2C_SMBUS";
+ return EIO;
+ }
+
+ memcpy(data, &read_data.block[1], size);
+ *bytes_read = size;
+
+ return 0;
+}
+
+int32_t I2cDriverI2cDev::Write(const void* data,
+ uint32_t size,
+ uint32_t* bytes_written) {
+ *bytes_written = char_interface_->Write(fd_, data, size);
+ return *bytes_written == size ? 0 : EIO;
+}
+
+int32_t I2cDriverI2cDev::WriteRegByte(uint8_t reg, uint8_t val) {
+ union i2c_smbus_data write_data;
+ write_data.byte = val;
+ struct i2c_smbus_ioctl_data smbus_args;
+ smbus_args.command = reg;
+ smbus_args.read_write = I2C_SMBUS_WRITE;
+ smbus_args.size = I2C_SMBUS_BYTE_DATA;
+ smbus_args.data = &write_data;
+
+ if (char_interface_->Ioctl(fd_, I2C_SMBUS, &smbus_args) < 0) {
+ return EIO;
+ }
+ return 0;
+}
+
+int32_t I2cDriverI2cDev::WriteRegWord(uint8_t reg, uint16_t val) {
+ union i2c_smbus_data write_data;
+ write_data.word = val;
+ struct i2c_smbus_ioctl_data smbus_args;
+ smbus_args.command = reg;
+ smbus_args.read_write = I2C_SMBUS_WRITE;
+ smbus_args.size = I2C_SMBUS_WORD_DATA;
+ smbus_args.data = &write_data;
+
+ if (char_interface_->Ioctl(fd_, I2C_SMBUS, &smbus_args) < 0) {
+ return EIO;
+ }
+ return 0;
+}
+
+int32_t I2cDriverI2cDev::WriteRegBuffer(uint8_t reg,
+ const uint8_t* data,
+ uint32_t size,
+ uint32_t* bytes_written) {
+ *bytes_written = 0;
+ if (size > I2C_SMBUS_BLOCK_MAX) {
+ LOG(WARNING) << "Can't write more than 32 bytes at a time.";
+ return EINVAL;
+ }
+
+ union i2c_smbus_data write_data;
+ write_data.block[0] = size;
+ memcpy(&write_data.block[1], data, size);
+
+ struct i2c_smbus_ioctl_data smbus_args;
+ smbus_args.command = reg;
+ smbus_args.read_write = I2C_SMBUS_WRITE;
+ smbus_args.size = I2C_SMBUS_I2C_BLOCK_DATA;
+ smbus_args.data = &write_data;
+
+ if (char_interface_->Ioctl(fd_, I2C_SMBUS, &smbus_args) < 0) {
+ LOG(ERROR) << "Failed I2C_SMBUS";
+ return EIO;
+ }
+
+ *bytes_written = size;
+
+ return 0;
+}
+
+} // namespace
diff --git a/peripheralmanager/daemon/i2c_driver_i2cdev.h b/peripheralmanager/daemon/i2c_driver_i2cdev.h
new file mode 100644
index 0000000..8282b47
--- /dev/null
+++ b/peripheralmanager/daemon/i2c_driver_i2cdev.h
@@ -0,0 +1,70 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_DAEMON_I2C_DRIVER_I2CDEV_H_
+#define SYSTEM_PERIPHERALMANAGER_DAEMON_I2C_DRIVER_I2CDEV_H_
+
+#include <stdint.h>
+
+#include <memory>
+
+#include <base/macros.h>
+
+#include "char_device.h"
+#include "i2c_driver.h"
+
+namespace android {
+
+class I2cDriverI2cDev : public I2cDriverInterface {
+ public:
+ explicit I2cDriverI2cDev(CharDeviceFactory* char_device_factory);
+ ~I2cDriverI2cDev();
+
+ static std::string Compat() { return "I2CDEV"; }
+
+ bool Init(uint32_t bus_id, uint32_t address) override;
+
+ int32_t Read(void* data, uint32_t size, uint32_t* bytes_read) override;
+ int32_t ReadRegByte(uint8_t reg, uint8_t* val) override;
+ int32_t ReadRegWord(uint8_t reg, uint16_t* val) override;
+ int32_t ReadRegBuffer(uint8_t reg,
+ uint8_t* data,
+ uint32_t size,
+ uint32_t* bytes_read) override;
+
+ int32_t Write(const void* data,
+ uint32_t size,
+ uint32_t* bytes_written) override;
+ int32_t WriteRegByte(uint8_t reg, uint8_t val) override;
+ int32_t WriteRegWord(uint8_t reg, uint16_t val) override;
+ int32_t WriteRegBuffer(uint8_t reg,
+ const uint8_t* data,
+ uint32_t size,
+ uint32_t* bytes_written) override;
+
+ private:
+ int fd_;
+
+ // Used for unit testing and is null in production.
+ // Ownership is in the test and outlives this class.
+ CharDeviceFactory* char_device_factory_;
+ std::unique_ptr<CharDeviceInterface> char_interface_;
+ DISALLOW_COPY_AND_ASSIGN(I2cDriverI2cDev);
+};
+
+} // namespace android
+
+#endif // SYSTEM_PERIPHERALMANAGER_DAEMON_I2C_DRIVER_I2CDEV_H_
diff --git a/peripheralmanager/daemon/i2c_manager.cc b/peripheralmanager/daemon/i2c_manager.cc
new file mode 100644
index 0000000..7ca084e
--- /dev/null
+++ b/peripheralmanager/daemon/i2c_manager.cc
@@ -0,0 +1,126 @@
+/*
+ * 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 "i2c_manager.h"
+
+#include <base/logging.h>
+
+#include "pin_mux_manager.h"
+
+namespace android {
+
+std::unique_ptr<I2cManager> g_i2c_manager;
+
+I2cManager::I2cManager() {}
+
+I2cManager::~I2cManager() {}
+
+// static
+I2cManager* I2cManager::GetI2cManager() {
+ if (!g_i2c_manager) {
+ g_i2c_manager.reset(new I2cManager());
+ }
+ return g_i2c_manager.get();
+}
+
+// static
+void I2cManager::ResetI2cManager() {
+ g_i2c_manager.reset();
+}
+
+bool I2cManager::RegisterI2cDevBus(const std::string& name,
+ uint32_t bus) {
+ if (i2cdev_buses_.count(name))
+ return false;
+ i2cdev_buses_.emplace(name, I2cDevBus(bus));
+ return true;
+}
+
+std::vector<std::string> I2cManager::GetI2cDevBuses() {
+ std::vector<std::string> buses;
+ for (auto& i : i2cdev_buses_)
+ buses.push_back(i.first);
+ return buses;
+}
+
+bool I2cManager::HasI2cDevBus(const std::string& name) {
+ return i2cdev_buses_.count(name);
+}
+
+bool I2cManager::RegisterDriver(
+ std::unique_ptr<I2cDriverInfoBase> driver_info) {
+ std::string key = driver_info->Compat();
+ driver_infos_[key] = std::move(driver_info);
+ return true;
+}
+
+bool I2cManager::SetPinMux(const std::string& name, const std::string& mux) {
+ auto bus_it = i2cdev_buses_.find(name);
+ if (bus_it == i2cdev_buses_.end())
+ return false;
+ bus_it->second.mux = mux;
+ bus_it->second.mux_group = mux;
+ return true;
+}
+
+bool I2cManager::SetPinMuxWithGroup(const std::string& name,
+ const std::string& mux,
+ const std::string& group) {
+ auto bus_it = i2cdev_buses_.find(name);
+ if (bus_it == i2cdev_buses_.end())
+ return false;
+ bus_it->second.mux = mux;
+ bus_it->second.mux_group = group;
+ return true;
+}
+
+std::unique_ptr<I2cDevice> I2cManager::OpenI2cDevice(const std::string& name, uint32_t address) {
+ LOG(INFO) << "OpenI2cDevice " << name << " " << address;
+ // Get the Bus from the BSP.
+ auto bus_it = i2cdev_buses_.find(name);
+ if (bus_it == i2cdev_buses_.end())
+ return nullptr;
+
+ // Check its not already in use
+ if (bus_it->second.driver_.count(address)) {
+ return nullptr;
+ }
+
+ // Find a driver.
+ // Currently there is only hardcoded support for I2CDEV
+ auto driver_info_it = driver_infos_.find("I2CDEV");
+
+ // Fail if there is no driver.
+ if (driver_info_it == driver_infos_.end())
+ return nullptr;
+
+ std::unique_ptr<I2cDriverInterface> driver(driver_info_it->second->Probe());
+
+ if (!driver->Init(bus_it->second.bus, address))
+ return nullptr;
+
+ // Set Pin muxing.
+ if (!bus_it->second.mux.empty()) {
+ PinMuxManager::GetPinMuxManager()->SetSource(bus_it->second.mux,
+ bus_it->second.mux_group);
+ }
+
+ bus_it->second.driver_[address] = std::move(driver);
+
+ return std::unique_ptr<I2cDevice>(new I2cDevice(&(bus_it->second), address));
+}
+
+} // namespace android
diff --git a/peripheralmanager/daemon/i2c_manager.h b/peripheralmanager/daemon/i2c_manager.h
new file mode 100644
index 0000000..5627b4d
--- /dev/null
+++ b/peripheralmanager/daemon/i2c_manager.h
@@ -0,0 +1,135 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_DAEMON_I2C_MANAGER_H_
+#define SYSTEM_PERIPHERALMANAGER_DAEMON_I2C_MANAGER_H_
+
+#include <stdint.h>
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <base/macros.h>
+
+#include "peripheralmanager/constants.h"
+#include "pin_mux_manager.h"
+#include "i2c_driver.h"
+
+namespace android {
+
+struct I2cDevBus {
+ explicit I2cDevBus(uint32_t b) : bus(b) {}
+ uint32_t bus;
+ std::string mux;
+ std::string mux_group;
+ std::map<uint32_t, std::unique_ptr<I2cDriverInterface>> driver_;
+};
+
+class I2cDevice {
+ public:
+ I2cDevice(I2cDevBus* bus, uint32_t address) : bus_(bus), address_(address) {}
+ ~I2cDevice() {
+ if (!bus_->mux.empty()) {
+ PinMuxManager::GetPinMuxManager()->ReleaseSource(bus_->mux,
+ bus_->mux_group);
+ }
+ bus_->driver_.erase(address_);
+ }
+
+ int32_t Read(void* data, uint32_t size, uint32_t* bytes_read) {
+ return bus_->driver_[address_]->Read(data, size, bytes_read);
+ }
+
+ int32_t ReadRegByte(uint8_t reg, uint8_t* val) {
+ return bus_->driver_[address_]->ReadRegByte(reg, val);
+ }
+
+ int32_t ReadRegWord(uint8_t reg, uint16_t* val) {
+ return bus_->driver_[address_]->ReadRegWord(reg, val);
+ }
+
+ int32_t ReadRegBuffer(uint8_t reg,
+ uint8_t* data,
+ uint32_t size,
+ uint32_t* bytes_read) {
+ return bus_->driver_[address_]->ReadRegBuffer(reg, data, size, bytes_read);
+ }
+
+ int32_t Write(const void* data, uint32_t size, uint32_t* bytes_written) {
+ return bus_->driver_[address_]->Write(data, size, bytes_written);
+ }
+
+ int32_t WriteRegByte(uint8_t reg, uint8_t val) {
+ return bus_->driver_[address_]->WriteRegByte(reg, val);
+ }
+
+ int32_t WriteRegWord(uint8_t reg, uint16_t val) {
+ return bus_->driver_[address_]->WriteRegWord(reg, val);
+ }
+
+ int32_t WriteRegBuffer(uint8_t reg,
+ const uint8_t* data,
+ uint32_t size,
+ uint32_t* bytes_written) {
+ return bus_->driver_[address_]->WriteRegBuffer(
+ reg, data, size, bytes_written);
+ }
+
+ private:
+ I2cDevBus* bus_;
+ uint32_t address_;
+};
+
+class I2cManager {
+ public:
+ friend class I2cManagerTest;
+ ~I2cManager();
+
+ // Get the singleton.
+ static I2cManager* GetI2cManager();
+
+ // Resets the global I2c manager (used for testing).
+ static void ResetI2cManager();
+
+ bool RegisterI2cDevBus(const std::string& name, uint32_t bus);
+
+ std::vector<std::string> GetI2cDevBuses();
+ bool HasI2cDevBus(const std::string& name);
+
+ bool SetPinMux(const std::string& name, const std::string& mux);
+ bool SetPinMuxWithGroup(const std::string& name,
+ const std::string& mux,
+ const std::string& group);
+
+ bool RegisterDriver(std::unique_ptr<I2cDriverInfoBase> driver_info);
+
+ std::unique_ptr<I2cDevice> OpenI2cDevice(const std::string& name,
+ uint32_t address);
+
+ private:
+ I2cManager();
+
+ std::map<std::string, std::unique_ptr<I2cDriverInfoBase>> driver_infos_;
+ std::map<std::string, I2cDevBus> i2cdev_buses_;
+
+ DISALLOW_COPY_AND_ASSIGN(I2cManager);
+};
+
+} // namespace android
+
+#endif // SYSTEM_PERIPHERALMANAGER_DAEMON_I2C_MANAGER_H_
diff --git a/peripheralmanager/daemon/led_driver.h b/peripheralmanager/daemon/led_driver.h
new file mode 100644
index 0000000..15c25e6
--- /dev/null
+++ b/peripheralmanager/daemon/led_driver.h
@@ -0,0 +1,71 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_DAEMON_LED_DRIVER_H_
+#define SYSTEM_PERIPHERALMANAGER_DAEMON_LED_DRIVER_H_
+
+#include <stdint.h>
+
+#include <memory>
+#include <string>
+
+#include <base/macros.h>
+
+namespace android {
+
+class LedDriverInterface {
+ public:
+ LedDriverInterface() {}
+ virtual ~LedDriverInterface() {}
+
+ // TODO(leecam): Init should have generic params.
+ virtual bool Init(const std::string& name) = 0;
+
+ virtual bool SetBrightness(uint32_t val) = 0;
+
+ virtual bool GetBrightness(uint32_t* val) = 0;
+
+ virtual bool GetMaxBrightness(uint32_t* val) = 0;
+};
+
+class LedDriverInfoBase {
+ public:
+ LedDriverInfoBase() {}
+ virtual ~LedDriverInfoBase() {}
+
+ virtual std::string Compat() = 0;
+ virtual std::unique_ptr<LedDriverInterface> Probe() = 0;
+};
+
+template <class T, class PARAM>
+class LedDriverInfo : public LedDriverInfoBase {
+ public:
+ explicit LedDriverInfo(PARAM param) : param_(param) {}
+ ~LedDriverInfo() override {}
+
+ std::string Compat() override { return T::Compat(); }
+
+ std::unique_ptr<LedDriverInterface> Probe() override {
+ return std::unique_ptr<LedDriverInterface>(new T(param_));
+ }
+
+ private:
+ PARAM param_;
+};
+
+} // namespace android
+
+#endif // SYSTEM_PERIPHERALMANAGER_DAEMON_LED_DRIVER_H_
diff --git a/peripheralmanager/daemon/led_driver_sysfs.cc b/peripheralmanager/daemon/led_driver_sysfs.cc
new file mode 100644
index 0000000..0292082
--- /dev/null
+++ b/peripheralmanager/daemon/led_driver_sysfs.cc
@@ -0,0 +1,109 @@
+/*
+ * 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 "led_driver_sysfs.h"
+
+#include <fcntl.h>
+#include <string>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <base/logging.h>
+
+namespace android {
+namespace {
+
+const char kSysfsLedPathPrefix[] = "/sys/class/leds/";
+const char kMaxBrightnessFilename[] = "max_brightness";
+const char kBrightnessFilename[] = "brightness";
+
+} // namespace
+
+LedDriverSysfs::LedDriverSysfs(std::string* prefix)
+ : fd_(-1), prefix_(prefix) {}
+
+LedDriverSysfs::~LedDriverSysfs() {
+ if (fd_ >= 0) {
+ close(fd_);
+ }
+}
+
+bool LedDriverSysfs::Init(const std::string& name) {
+ LOG(INFO) << "Opening " << name;
+
+ // If a custom prefix was defined, use it.
+ std::string path = prefix_ ? *prefix_ + name : kSysfsLedPathPrefix + name;
+
+ int fd = open(path.c_str(), O_RDONLY);
+ if (fd < 0) {
+ PLOG(WARNING) << "Failed to open " << path;
+ return false;
+ }
+
+ fd_ = fd;
+ return true;
+}
+
+bool LedDriverSysfs::SetBrightness(uint32_t val) {
+ return WriteToFile(kBrightnessFilename, std::to_string(val));
+}
+
+bool LedDriverSysfs::GetBrightness(uint32_t* val) {
+ std::string str_val;
+ if (!ReadFromFile(kBrightnessFilename, &str_val))
+ return false;
+ *val = std::stoi(str_val);
+ return true;
+}
+
+bool LedDriverSysfs::GetMaxBrightness(uint32_t* val) {
+ std::string str_val;
+ if (!ReadFromFile(kMaxBrightnessFilename, &str_val))
+ return false;
+ *val = std::stoi(str_val);
+ return true;
+}
+
+bool LedDriverSysfs::ReadFromFile(const std::string& file, std::string* value) {
+ int fd = openat(fd_, file.c_str(), O_RDONLY);
+ if (fd < 0)
+ return false;
+ char tmp_buf[16] = "";
+ ssize_t bytes = read(fd, tmp_buf, sizeof(tmp_buf));
+ close(fd);
+ if (bytes < 0)
+ return false;
+ value->assign(tmp_buf, bytes);
+ return true;
+}
+
+bool LedDriverSysfs::WriteToFile(const std::string& file,
+ const std::string& value) {
+ int fd = openat(fd_, file.c_str(), O_RDWR);
+ if (fd < 0)
+ return false;
+
+ ssize_t bytes = write(fd, value.c_str(), value.size());
+ close(fd);
+ if (bytes < 0)
+ return false;
+ if ((size_t)bytes != value.size())
+ return false;
+ return true;
+}
+
+} // namespace android
diff --git a/peripheralmanager/daemon/led_driver_sysfs.h b/peripheralmanager/daemon/led_driver_sysfs.h
new file mode 100644
index 0000000..c4c46fc
--- /dev/null
+++ b/peripheralmanager/daemon/led_driver_sysfs.h
@@ -0,0 +1,55 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_DAEMON_LED_DRIVER_SYSFS_H_
+#define SYSTEM_PERIPHERALMANAGER_DAEMON_LED_DRIVER_SYSFS_H_
+
+#include <stdint.h>
+
+#include <base/macros.h>
+
+#include "led_driver.h"
+
+namespace android {
+
+class LedDriverSysfs : public LedDriverInterface {
+ public:
+ explicit LedDriverSysfs(std::string* prefix);
+ ~LedDriverSysfs();
+
+ static std::string Compat() { return "LEDSYSFS"; }
+
+ bool Init(const std::string& name) override;
+ bool SetBrightness(uint32_t val) override;
+ bool GetBrightness(uint32_t* val) override;
+ bool GetMaxBrightness(uint32_t* val) override;
+
+ private:
+ bool ReadFromFile(const std::string& file, std::string* value);
+ bool WriteToFile(const std::string& file, const std::string& value);
+
+ int fd_;
+
+ // Used for unit test only.
+ // Ownership is in the test.
+ std::string* prefix_;
+
+ DISALLOW_COPY_AND_ASSIGN(LedDriverSysfs);
+};
+
+} // namespace android
+
+#endif // SYSTEM_PERIPHERALMANAGER_DAEMON_LED_DRIVER_SYSFS_H_
diff --git a/peripheralmanager/daemon/led_manager.cc b/peripheralmanager/daemon/led_manager.cc
new file mode 100644
index 0000000..72e200f
--- /dev/null
+++ b/peripheralmanager/daemon/led_manager.cc
@@ -0,0 +1,107 @@
+/*
+ * 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 "led_manager.h"
+
+#include <base/logging.h>
+
+namespace android {
+
+std::unique_ptr<LedManager> g_led_manager;
+
+LedManager::LedManager() {}
+
+LedManager::~LedManager() {}
+
+// static
+LedManager* LedManager::GetLedManager() {
+ if (!g_led_manager) {
+ g_led_manager.reset(new LedManager());
+ }
+ return g_led_manager.get();
+}
+
+// static
+void LedManager::ResetLedManager() {
+ g_led_manager.reset();
+}
+
+bool LedManager::RegisterDriver(
+ std::unique_ptr<LedDriverInfoBase> driver_info) {
+ std::string key = driver_info->Compat();
+ driver_infos_[key] = std::move(driver_info);
+ return true;
+}
+
+bool LedManager::RegisterLedSysfs(const std::string& name,
+ const std::string& led_name) {
+ if (leds_.count(name))
+ return false;
+ leds_[name].name = led_name;
+ return true;
+}
+
+std::unique_ptr<Led> LedManager::OpenLed(const std::string& name) {
+ auto led_it = leds_.find(name);
+ if (led_it == leds_.end()) {
+ LOG(WARNING) << "LedManager: Led not found. " << name;
+ return nullptr;
+ }
+
+ // Check its not alread in use
+ if (led_it->second.driver_) {
+ LOG(WARNING) << "LedManager: Led in use. " << name;
+ return nullptr;
+ }
+
+ // Find a driver.
+ auto driver_info_it = driver_infos_.find("LEDSYSFS");
+
+ // Fail if there is no driver.
+ if (driver_info_it == driver_infos_.end()) {
+ LOG(WARNING) << "LedManager: Failed to find driver " << name;
+ return nullptr;
+ }
+
+ std::unique_ptr<LedDriverInterface> driver(driver_info_it->second->Probe());
+
+ // Set pin mux
+ if (!led_it->second.mux.empty()) {
+ // TODO(leecam): Enable pin muxing
+ }
+
+ if (!driver->Init(led_it->second.name)) {
+ LOG(WARNING) << "LedManager: Failed to init driver " << name;
+ return nullptr;
+ }
+
+ led_it->second.driver_ = std::move(driver);
+
+ return std::unique_ptr<Led>(new Led(&(led_it->second)));
+}
+
+std::vector<std::string> LedManager::GetLeds() {
+ std::vector<std::string> leds;
+ for (auto& i : leds_)
+ leds.push_back(i.first);
+ return leds;
+}
+
+bool LedManager::HasLed(const std::string& name) {
+ return leds_.count(name);
+}
+
+} // namespace android
diff --git a/peripheralmanager/daemon/led_manager.h b/peripheralmanager/daemon/led_manager.h
new file mode 100644
index 0000000..b6c93f9
--- /dev/null
+++ b/peripheralmanager/daemon/led_manager.h
@@ -0,0 +1,95 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_DAEMON_LED_MANAGER_H_
+#define SYSTEM_PERIPHERALMANAGER_DAEMON_LED_MANAGER_H_
+
+#include <stdint.h>
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <base/macros.h>
+
+#include "led_driver.h"
+#include "pin_mux_manager.h"
+
+namespace android {
+
+struct LedSysfs {
+ std::string name;
+ std::string mux;
+ std::unique_ptr<LedDriverInterface> driver_;
+};
+
+class Led {
+ public:
+ explicit Led(LedSysfs* led) : led_(led) {}
+ ~Led() {
+ if (!led_->mux.empty()) {
+ // TODO(leecam): Set up pin muxing
+ }
+ led_->driver_.reset();
+ }
+
+ bool SetBrightness(uint32_t val) { return led_->driver_->SetBrightness(val); }
+
+ bool GetBrightness(uint32_t* val) {
+ return led_->driver_->GetBrightness(val);
+ }
+
+ bool GetMaxBrightness(uint32_t* val) {
+ return led_->driver_->GetMaxBrightness(val);
+ }
+
+ private:
+ LedSysfs* led_;
+};
+
+class LedManager {
+ public:
+ friend class LedManagerTest;
+ ~LedManager();
+
+ // Get the singleton.
+ static LedManager* GetLedManager();
+ static void ResetLedManager();
+
+ // Used by the BSP to tell PMan of an sysfs led.
+ bool RegisterLedSysfs(const std::string& name, const std::string& led_name);
+ bool SetPinMux(const std::string& name, const std::string& mux);
+
+ std::vector<std::string> GetLeds();
+ bool HasLed(const std::string& name);
+
+ bool RegisterDriver(std::unique_ptr<LedDriverInfoBase> driver_info);
+
+ std::unique_ptr<Led> OpenLed(const std::string& name);
+
+ private:
+ LedManager();
+
+ std::map<std::string, std::unique_ptr<LedDriverInfoBase>> driver_infos_;
+ std::map<std::string, LedSysfs> leds_;
+
+ DISALLOW_COPY_AND_ASSIGN(LedManager);
+};
+
+} // namespace android
+
+#endif // SYSTEM_PERIPHERALMANAGER_DAEMON_LED_MANAGER_H_
diff --git a/peripheralmanager/daemon/main.cc b/peripheralmanager/daemon/main.cc
new file mode 100644
index 0000000..461f401
--- /dev/null
+++ b/peripheralmanager/daemon/main.cc
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2015 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 <sysexits.h>
+
+#include <base/logging.h>
+#include <base/macros.h>
+#include <binderwrapper/binder_wrapper.h>
+#include <brillo/binder_watcher.h>
+#include <brillo/daemons/daemon.h>
+#include <brillo/flag_helper.h>
+
+#include "peripheral_manager.h"
+
+namespace {
+
+class PeripheralManagerDaemon : public brillo::Daemon {
+ public:
+ PeripheralManagerDaemon() {};
+
+ ~PeripheralManagerDaemon() override = default;
+
+ private:
+ // brillo::Daemon:
+ int OnInit() override {
+ int result = brillo::Daemon::OnInit();
+ if (result != EX_OK)
+ return result;
+
+ android::BinderWrapper::Create();
+ if (!binder_watcher_.Init())
+ return EX_OSERR;
+ if (!peripheral_manager_.Init())
+ return EX_OSERR;
+
+ LOG(INFO) << "Initialization complete";
+ return EX_OK;
+ }
+
+ brillo::BinderWatcher binder_watcher_;
+ android::PeripheralManager peripheral_manager_;
+
+ DISALLOW_COPY_AND_ASSIGN(PeripheralManagerDaemon);
+};
+
+} // namespace
+
+int main(int argc, char *argv[]) {
+ brillo::FlagHelper::Init(argc, argv, "Peripheral management daemon");
+ logging::InitLogging(logging::LoggingSettings());
+ return PeripheralManagerDaemon().Run();
+}
diff --git a/peripheralmanager/daemon/peripheral_manager.cc b/peripheralmanager/daemon/peripheral_manager.cc
new file mode 100644
index 0000000..ba8c6aa
--- /dev/null
+++ b/peripheralmanager/daemon/peripheral_manager.cc
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2015 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.h"
+
+#include <base/logging.h>
+#include <binderwrapper/binder_wrapper.h>
+#include <binderwrapper/stub_binder_wrapper.h>
+#include <hardware/hardware.h>
+#include <hardware/peripheral_io.h>
+
+#include "gpio_driver_sysfs.h"
+#include "gpio_manager.h"
+#include "i2c_driver_i2cdev.h"
+#include "i2c_manager.h"
+#include "led_driver_sysfs.h"
+#include "led_manager.h"
+#include "pin_mux_manager.h"
+#include "spi_driver_spidev.h"
+#include "uart_driver_sysfs.h"
+#include "uart_manager.h"
+
+namespace android {
+namespace {
+
+// Gpio callbacks
+static int RegisterGpioSysfs(const char* name, uint32_t index) {
+ return GpioManager::GetGpioManager()->RegisterGpioSysfs(name, index);
+}
+
+static int SetGpioPinMux(const char* name, const char* source) {
+ return GpioManager::GetGpioManager()->SetPinMux(name, source);
+}
+
+// Spi callbacks
+static int RegisterSpiDevBus(const char* name, uint32_t bus, uint32_t cs) {
+ return SpiManager::GetSpiManager()->RegisterSpiDevBus(name, bus, cs);
+}
+
+static int SetSpiPinMux(const char* name, const char* source) {
+ return SpiManager::GetSpiManager()->SetPinMux(name, source);
+}
+
+// Led callbacks
+static int RegisterLedSysfs(const char* name, const char* sysfs_name) {
+ return LedManager::GetLedManager()->RegisterLedSysfs(name, sysfs_name);
+}
+
+// Uart callbacks
+static int RegisterUartBus(const char* name, const char* dev_name) {
+ return UartManager::GetManager()->RegisterUartDevice(name, dev_name);
+}
+
+static int SetUartPinMux(const char* name, const char* source) {
+ return UartManager::GetManager()->SetPinMux(name, source);
+}
+
+// I2c callbacks
+static int RegisterI2cDevBus(const char* name, uint32_t bus) {
+ return I2cManager::GetI2cManager()->RegisterI2cDevBus(name, bus);
+}
+
+static int SetI2cPinMux(const char* name, const char* source) {
+ return I2cManager::GetI2cManager()->SetPinMux(name, source);
+}
+
+// Pin Mux callbacks.
+static int RegisterPin(const char* name,
+ int gpio,
+ pin_mux_callbacks callbacks) {
+ return PinMuxManager::GetPinMuxManager()->RegisterPin(name, gpio, callbacks);
+}
+
+static int RegisterPinGroup(const char* name, char** pins, size_t nr_pins) {
+ std::set<std::string> pins_set;
+ for (size_t i = 0; i < nr_pins; i++)
+ pins_set.emplace(pins[i]);
+ return PinMuxManager::GetPinMuxManager()->RegisterPinGroup(name, pins_set);
+}
+
+static int RegisterSource(const char* name, char** groups, size_t nr_groups) {
+ std::set<std::string> groups_set;
+ for (size_t i = 0; i < nr_groups; i++)
+ groups_set.emplace(groups[i]);
+ return PinMuxManager::GetPinMuxManager()->RegisterSource(name, groups_set);
+}
+
+static int RegisterSimpleSource(const char* name,
+ const char** pins,
+ size_t nr_pins) {
+ std::set<std::string> pins_set;
+ for (size_t i = 0; i < nr_pins; i++)
+ pins_set.emplace(pins[i]);
+ return PinMuxManager::GetPinMuxManager()->RegisterSimpleSource(name,
+ pins_set);
+}
+
+} // namespace
+
+PeripheralManager::PeripheralManager() {}
+
+PeripheralManager::~PeripheralManager() = default;
+
+bool PeripheralManager::Init() {
+ if (!RegisterDrivers())
+ return false;
+
+ if (!InitHal())
+ return false;
+
+ String8 interface_desc(getInterfaceDescriptor());
+ return BinderWrapper::Get()->RegisterService(interface_desc.string(), this);
+}
+
+Status PeripheralManager::GetClient(const sp<IBinder>& lifeline,
+ sp<os::IPeripheralManagerClient>* client) {
+ sp<PeripheralManagerClient> c = new PeripheralManagerClient;
+ *client = c;
+
+ lifeline->linkToDeath(this);
+ mapping_.emplace(lifeline.get(), c);
+ VLOG(1) << "client connecting " << mapping_.size();
+
+ return Status::ok();
+}
+
+void PeripheralManager::binderDied(const wp<IBinder>& who) {
+ mapping_.erase(who.unsafe_get());
+ VLOG(1) << "client disconnecting " << mapping_.size();
+}
+
+bool PeripheralManager::RegisterDrivers() {
+ if (!SpiManager::GetSpiManager()->RegisterDriver(
+ std::unique_ptr<SpiDriverInfoBase>(
+ new SpiDriverInfo<SpiDriverSpiDev, CharDeviceFactory*>(
+ nullptr)))) {
+ LOG(ERROR) << "Failed to load driver: SpiDriverSpiDev";
+ return false;
+ }
+ if (!I2cManager::GetI2cManager()->RegisterDriver(
+ std::unique_ptr<I2cDriverInfoBase>(
+ new I2cDriverInfo<I2cDriverI2cDev, CharDeviceFactory*>(
+ nullptr)))) {
+ LOG(ERROR) << "Failed to load driver: I2cDriverI2cDev";
+ return false;
+ }
+ if (!GpioManager::GetGpioManager()->RegisterDriver(
+ std::unique_ptr<GpioDriverInfoBase>(
+ new GpioDriverInfo<GpioDriverSysfs, void*>(nullptr)))) {
+ LOG(ERROR) << "Failed to load driver: GpioDriverSysfs";
+ return false;
+ }
+ if (!LedManager::GetLedManager()->RegisterDriver(
+ std::unique_ptr<LedDriverInfoBase>(
+ new LedDriverInfo<LedDriverSysfs, std::string*>(nullptr)))) {
+ LOG(ERROR) << "Failed to load driver: LedDriverSysfs";
+ return false;
+ }
+ if (!UartManager::GetManager()->RegisterDriver(
+ std::unique_ptr<UartDriverInfoBase>(
+ new UartDriverInfo<UartDriverSysfs, CharDeviceFactory*>(
+ nullptr)))) {
+ LOG(ERROR) << "Failed to load driver: UartDriverSysfs";
+ return false;
+ }
+ return true;
+}
+
+bool PeripheralManager::InitHal() {
+ const hw_module_t* module = nullptr;
+ if (hw_get_module(PERIPHERAL_IO_HARDWARE_MODULE_ID, &module) != 0) {
+ LOG(ERROR) << "Failed to load HAL" << module;
+ return true;
+ }
+
+ const peripheral_io_module_t* peripheral_module =
+ reinterpret_cast<const peripheral_io_module_t*>(module);
+
+ struct peripheral_registration_cb_t callbacks = {
+ // Gpio
+ .register_gpio_sysfs = RegisterGpioSysfs,
+ .set_gpio_pin_mux = SetGpioPinMux,
+
+ // Spi
+ .register_spi_dev_bus = RegisterSpiDevBus,
+ .set_spi_pin_mux = SetSpiPinMux,
+
+ // Led
+ .register_led_sysfs = RegisterLedSysfs,
+
+ // Uart
+ .register_uart_bus = RegisterUartBus,
+ .set_uart_pin_mux = SetUartPinMux,
+
+ // I2c
+ .register_i2c_dev_bus = RegisterI2cDevBus,
+ .set_i2c_pin_mux = SetI2cPinMux,
+
+ // Pin Mux
+ .register_pin = RegisterPin,
+ .register_pin_group = RegisterPinGroup,
+ .register_source = RegisterSource,
+ .register_simple_source = RegisterSimpleSource,
+ };
+
+ peripheral_module->register_devices(peripheral_module, &callbacks);
+
+ return true;
+}
+
+} // namespace android
diff --git a/peripheralmanager/daemon/peripheral_manager.h b/peripheralmanager/daemon/peripheral_manager.h
new file mode 100644
index 0000000..8b5568f
--- /dev/null
+++ b/peripheralmanager/daemon/peripheral_manager.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_DAEMON_PERIPHERAL_MANAGER_H_
+#define SYSTEM_PERIPHERALMANAGER_DAEMON_PERIPHERAL_MANAGER_H_
+
+#include <map>
+
+#include <base/macros.h>
+
+#include <android/os/BnPeripheralManager.h>
+
+#include "peripheral_manager_client.h"
+
+using android::binder::Status;
+using android::os::BnPeripheralManager;
+
+namespace android {
+
+class PeripheralManager : public BnPeripheralManager,
+ public BnPeripheralManager::DeathRecipient {
+ public:
+ PeripheralManager();
+ ~PeripheralManager();
+
+ bool Init();
+
+ // IPeripheralManager Interface
+ Status GetClient(const sp<IBinder>& lifeline,
+ sp<os::IPeripheralManagerClient>* _aidl_return);
+
+ void binderDied(const wp<IBinder>& who) override;
+
+ private:
+ bool InitHal();
+ bool RegisterDrivers();
+
+ std::map<IBinder*, sp<PeripheralManagerClient>> mapping_;
+
+ DISALLOW_COPY_AND_ASSIGN(PeripheralManager);
+};
+
+} // namespace android
+
+#endif // SYSTEM_PERIPHERALMANAGER_DAEMON_PERIPHERAL_MANAGER_H_
diff --git a/peripheralmanager/daemon/peripheral_manager_client.cc b/peripheralmanager/daemon/peripheral_manager_client.cc
new file mode 100644
index 0000000..8dc30ea
--- /dev/null
+++ b/peripheralmanager/daemon/peripheral_manager_client.cc
@@ -0,0 +1,566 @@
+/*
+ * 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
diff --git a/peripheralmanager/daemon/peripheral_manager_client.h b/peripheralmanager/daemon/peripheral_manager_client.h
new file mode 100644
index 0000000..ee9abe4
--- /dev/null
+++ b/peripheralmanager/daemon/peripheral_manager_client.h
@@ -0,0 +1,197 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_DAEMON_PERIPHERAL_MANAGER_CLIENT_H_
+#define SYSTEM_PERIPHERALMANAGER_DAEMON_PERIPHERAL_MANAGER_CLIENT_H_
+
+#include <map>
+#include <memory>
+#include <string>
+
+#include <base/macros.h>
+
+#include <android/os/BnPeripheralManagerClient.h>
+
+#include "gpio_manager.h"
+#include "i2c_manager.h"
+#include "led_manager.h"
+#include "spi_manager.h"
+#include "uart_manager.h"
+
+using android::binder::Status;
+using android::os::BnPeripheralManagerClient;
+
+namespace android {
+
+class PeripheralManagerClient : public BnPeripheralManagerClient {
+ public:
+ PeripheralManagerClient();
+ ~PeripheralManagerClient();
+
+ // Gpio functions.
+ Status ListGpio(std::vector<std::string>* gpios) override;
+
+ Status OpenGpio(const std::string& name) override;
+
+ Status ReleaseGpio(const std::string& name) override;
+
+ Status SetGpioEdge(const std::string& name, int type) override;
+
+ Status SetGpioActiveType(const std::string& name, int type) override;
+
+ Status SetGpioDirection(const std::string& name,
+ int direction) override;
+
+ Status SetGpioValue(const std::string& name, bool value) override;
+
+ Status GetGpioValue(const std::string& name, bool* value) override;
+
+ Status GetGpioPollingFd(const std::string& name,
+ ::android::base::unique_fd* fd) override;
+
+ // Spi functions.
+ Status ListSpiBuses(std::vector<std::string>* buses) override;
+
+ Status OpenSpiDevice(const std::string& name) override;
+
+ Status ReleaseSpiDevice(const std::string& name) override;
+
+ Status SpiDeviceWriteByte(const std::string& name,
+ int8_t byte) override;
+
+ Status SpiDeviceWriteBuffer(
+ const std::string& name,
+ const std::vector<uint8_t>& buffer) override;
+
+ Status 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 len) override;
+
+ Status SpiDeviceSetMode(const std::string& name, int mode) override;
+
+ Status SpiDeviceSetFrequency(const std::string& name,
+ int frequency_hz) override;
+
+ Status SpiDeviceSetBitJustification(const std::string& name,
+ bool lsb_first) override;
+
+ Status SpiDeviceSetBitsPerWord(const std::string& name,
+ int nbits) override;
+
+ Status SpiDeviceSetDelay(const std::string& name,
+ int delay_usecs) override;
+
+ // Led functions.
+ Status ListLeds(std::vector<std::string>* leds) override;
+
+ Status OpenLed(const std::string& name) override;
+
+ Status ReleaseLed(const std::string& name) override;
+
+ Status LedGetBrightness(const std::string& name,
+ int* brightness) override;
+ Status LedGetMaxBrightness(const std::string& name,
+ int* max_brightness) override;
+ Status LedSetBrightness(const std::string& name,
+ int brightness) override;
+
+ // I2c functions.
+ Status ListI2cBuses(std::vector<std::string>* buses) override;
+
+ Status OpenI2cDevice(const std::string& name,
+ int32_t address) override;
+
+ Status ReleaseI2cDevice(const std::string& name,
+ int32_t address) override;
+
+ Status I2cRead(const std::string& name,
+ int32_t address,
+ std::vector<uint8_t>* data,
+ int32_t size,
+ int32_t* bytes_read) override;
+
+ Status I2cReadRegByte(const std::string& name,
+ int32_t address,
+ int32_t reg,
+ int32_t* val) override;
+
+ Status I2cReadRegWord(const std::string& name,
+ int32_t address,
+ int32_t reg,
+ int32_t* val) override;
+
+ Status I2cReadRegBuffer(const std::string& name,
+ int32_t address,
+ int32_t reg,
+ std::vector<uint8_t>* data,
+ int32_t size,
+ int32_t* bytes_read) override;
+
+ Status I2cWrite(const std::string& name,
+ int32_t address,
+ const std::vector<uint8_t>& data,
+ int32_t* bytes_written) override;
+
+ Status I2cWriteRegByte(const std::string& name,
+ int32_t address,
+ int32_t reg,
+ int8_t val) override;
+
+ Status I2cWriteRegWord(const std::string& name,
+ int32_t address,
+ int32_t reg,
+ int32_t val) override;
+
+ Status I2cWriteRegBuffer(const std::string& name,
+ int32_t address,
+ int32_t reg,
+ const std::vector<uint8_t>& data,
+ int32_t* bytes_written) override;
+
+ // Uart functions.
+ Status ListUartDevices(std::vector<std::string>* devices) override;
+
+ Status OpenUartDevice(const std::string& name) override;
+
+ Status ReleaseUartDevice(const std::string& name) override;
+
+ Status SetUartDeviceBaudrate(const std::string& name,
+ int32_t baudrate) override;
+
+ Status UartDeviceWrite(const std::string& name,
+ const std::vector<uint8_t>& data,
+ int* bytes_written) override;
+
+ 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);
+};
+
+} // namespace android
+
+#endif // SYSTEM_PERIPHERALMANAGER_DAEMON_PERIPHERAL_MANAGER_CLIENT_H_
diff --git a/peripheralmanager/daemon/peripheralman.rc b/peripheralmanager/daemon/peripheralman.rc
new file mode 100644
index 0000000..578fac5
--- /dev/null
+++ b/peripheralmanager/daemon/peripheralman.rc
@@ -0,0 +1,4 @@
+service peripheralman /system/bin/peripheralman
+ class main
+ user root
+ group system
diff --git a/peripheralmanager/daemon/pin_mux_manager.cc b/peripheralmanager/daemon/pin_mux_manager.cc
new file mode 100644
index 0000000..96d7371
--- /dev/null
+++ b/peripheralmanager/daemon/pin_mux_manager.cc
@@ -0,0 +1,167 @@
+/*
+ * 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 "pin_mux_manager.h"
+
+#include <base/logging.h>
+
+namespace android {
+
+std::unique_ptr<PinMuxManager> g_pin_mux_manager;
+
+PinMuxManager::PinMuxManager() {}
+
+PinMuxManager::~PinMuxManager() {}
+
+// static
+PinMuxManager* PinMuxManager::GetPinMuxManager() {
+ if (!g_pin_mux_manager) {
+ g_pin_mux_manager.reset(new PinMuxManager());
+ }
+ return g_pin_mux_manager.get();
+}
+
+bool PinMuxManager::RegisterPin(std::string name,
+ bool gpio,
+ pin_mux_callbacks callbacks) {
+ if (pins_.count(name))
+ return false;
+ pins_[name] = {false, gpio, callbacks};
+ return true;
+}
+
+bool PinMuxManager::RegisterPinGroup(std::string name,
+ std::set<std::string> pins) {
+ if (groups_.count(name))
+ return false;
+
+ // Check each pin is valid.
+ for (auto& p : pins) {
+ if (!pins_.count(p))
+ return false;
+ }
+ groups_[name] = pins;
+ return true;
+}
+
+bool PinMuxManager::RegisterSource(std::string name,
+ std::set<std::string> groups) {
+ if (sources_.count(name))
+ return false;
+
+ // Check each group is valid.
+ for (auto& g : groups) {
+ if (!groups_.count(g))
+ return false;
+ }
+ sources_[name] = groups;
+ return true;
+}
+
+bool PinMuxManager::RegisterSimpleSource(std::string name,
+ std::set<std::string> pins) {
+ if (!RegisterPinGroup(name, pins))
+ return false;
+ if (!RegisterSource(name, {name})) {
+ // TODO(leecam): Unregister Group
+ return false;
+ }
+ return true;
+}
+
+bool PinMuxManager::SetSource(std::string name, std::string group) {
+ if (!sources_.count(name))
+ return false;
+
+ if (!sources_[name].count(group))
+ return false;
+
+ // Check to make sure each pin is not in use.
+ for (auto& p : groups_[group]) {
+ if (pins_[p].in_use)
+ return false;
+ }
+
+ // Enable each Pin
+ for (auto& p : groups_[group]) {
+ pins_[p].in_use = true;
+
+ // TODO(leecam): Handle failures here!!!
+ if (pins_[p].callbacks.mux_cb)
+ pins_[p].callbacks.mux_cb(p.c_str(), name.c_str());
+ }
+
+ return true;
+}
+
+void PinMuxManager::ReleaseSource(std::string name, std::string group) {
+ if (!sources_.count(name))
+ return;
+ if (!sources_[name].count(group))
+ return;
+ for (auto& p : groups_[group]) {
+ if (!pins_[p].in_use) {
+ LOG(WARNING) << "Releasig Pin " << p << " that is not in use.";
+ }
+ pins_[p].in_use = false;
+ }
+}
+
+bool PinMuxManager::SetSimpleSource(std::string name) {
+ return SetSource(name, name);
+}
+
+bool PinMuxManager::SetGpio(std::string name) {
+ if (!pins_.count(name)) {
+ LOG(WARNING) << "PinMuxManager: Pin not found " << name;
+ return false;
+ }
+ if (pins_[name].in_use) {
+ LOG(WARNING) << "PinMuxManager: Pin in use " << name;
+ return false;
+ }
+ if (pins_[name].callbacks.mux_cb) {
+ if (!pins_[name].callbacks.mux_cb(name.c_str(), nullptr))
+ return false;
+ }
+ pins_[name].in_use = true;
+ return true;
+}
+
+void PinMuxManager::ReleaseGpio(std::string name) {
+ if (!pins_.count(name))
+ return;
+ pins_[name].in_use = false;
+}
+
+bool PinMuxManager::SetGpioDirection(std::string name, bool output) {
+ if (!pins_.count(name)) {
+ LOG(WARNING) << "SetGpioDirection pin not found " << name;
+ return false;
+ }
+ // Check if not in use - this should maybe be a DCHECK as
+ // it shoudn't be able to happen.
+ if (!pins_[name].in_use) {
+ LOG(WARNING) << "SetGpioDirection not in use " << name;
+ return false;
+ }
+ if (pins_[name].callbacks.direction_cb)
+ return pins_[name].callbacks.direction_cb(name.c_str(), output);
+
+ return true;
+}
+
+} // namespace android
\ No newline at end of file
diff --git a/peripheralmanager/daemon/pin_mux_manager.h b/peripheralmanager/daemon/pin_mux_manager.h
new file mode 100644
index 0000000..e18ec4a
--- /dev/null
+++ b/peripheralmanager/daemon/pin_mux_manager.h
@@ -0,0 +1,81 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_DAEMON_PIN_MUX_MANAGER_H_
+#define SYSTEM_PERIPHERALMANAGER_DAEMON_PIN_MUX_MANAGER_H_
+
+#include <stdint.h>
+
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+#include <base/macros.h>
+
+#include <hardware/peripheral_io.h>
+
+namespace android {
+
+struct Pin {
+ bool in_use;
+ bool gpio;
+ pin_mux_callbacks callbacks;
+};
+
+class PinMuxManager {
+ public:
+ friend class PinMuxManagerTest;
+ ~PinMuxManager();
+
+ // Get the singleton.
+ static PinMuxManager* GetPinMuxManager();
+
+ // The following Register* functions as used to configure
+ // the pin mux configuation. These are called by the during
+ // BSP setup, using the HAL.
+ bool RegisterPin(std::string name, bool gpio, pin_mux_callbacks callbacks);
+ bool RegisterPinGroup(std::string name, std::set<std::string> pins);
+ bool RegisterSource(std::string name, std::set<std::string> groups);
+ // Helper that registers a source with a default group of the same name.
+ bool RegisterSimpleSource(std::string name, std::set<std::string> pins);
+
+ // Called by the device managers, e.g SpiManager.
+ // These are used to configure the pin muxing at runtime.
+ bool SetSource(std::string name, std::string group);
+ bool SetSimpleSource(std::string name);
+ void ReleaseSource(std::string name, std::string group);
+
+ // Used by the GpioManager to enable Gpio pins.
+ bool SetGpio(std::string name);
+ void ReleaseGpio(std::string name);
+ bool SetGpioDirection(std::string name, bool output);
+
+ private:
+ // Private constuctor as this class is accessed via a singleton.
+ PinMuxManager();
+
+ std::map<std::string, Pin> pins_;
+ std::map<std::string, std::set<std::string>> groups_;
+ std::map<std::string, std::set<std::string>> sources_;
+
+ DISALLOW_COPY_AND_ASSIGN(PinMuxManager);
+};
+
+} // namespace android
+
+#endif // SYSTEM_PERIPHERALMANAGER_DAEMON_PIN_MUX_MANAGER_H_
diff --git a/peripheralmanager/daemon/pin_mux_manager_unittest.cc b/peripheralmanager/daemon/pin_mux_manager_unittest.cc
new file mode 100644
index 0000000..aa0073c
--- /dev/null
+++ b/peripheralmanager/daemon/pin_mux_manager_unittest.cc
@@ -0,0 +1,87 @@
+/*
+ * 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 <stdio.h>
+
+#include <gtest/gtest.h>
+
+#include "pin_mux_manager.h"
+
+namespace android {
+
+class PinMuxManagerTest : public ::testing::Test {
+ public:
+ PinMuxManagerTest() {}
+ ~PinMuxManagerTest() = default;
+
+ protected:
+ PinMuxManager manager;
+ pin_mux_callbacks callbacks = {nullptr, nullptr};
+};
+
+TEST_F(PinMuxManagerTest, RegisterPin) {
+ ASSERT_TRUE(manager.RegisterPin("IO1", true, callbacks));
+ ASSERT_TRUE(manager.RegisterPin("IO2", true, callbacks));
+
+ ASSERT_FALSE(manager.RegisterPin("IO1", true, callbacks));
+ ASSERT_FALSE(manager.RegisterPin("IO2", true, callbacks));
+}
+
+TEST_F(PinMuxManagerTest, RegisterGroup) {
+ ASSERT_TRUE(manager.RegisterPin("IO1", true, callbacks));
+ ASSERT_TRUE(manager.RegisterPin("IO2", true, callbacks));
+ ASSERT_TRUE(manager.RegisterPin("IO3", true, callbacks));
+
+ ASSERT_TRUE(manager.RegisterPinGroup("Group1", {"IO1", "IO2", "IO3"}));
+ ASSERT_TRUE(manager.RegisterPinGroup("Group2", {"IO1"}));
+ ASSERT_FALSE(manager.RegisterPinGroup("Group1", {"IO1", "IO2", "IO3"}));
+ ASSERT_FALSE(manager.RegisterPinGroup("Group3", {"IO1", "BAD", "IO3"}));
+}
+
+TEST_F(PinMuxManagerTest, RegisterSource) {
+ ASSERT_TRUE(manager.RegisterPin("IO1", true, callbacks));
+ ASSERT_TRUE(manager.RegisterPin("IO2", true, callbacks));
+ ASSERT_TRUE(manager.RegisterPin("IO3", true, callbacks));
+
+ ASSERT_TRUE(manager.RegisterPinGroup("Group1", {"IO1", "IO2", "IO3"}));
+ ASSERT_TRUE(manager.RegisterPinGroup("Group2", {"IO1"}));
+
+ ASSERT_TRUE(manager.RegisterSource("Source1", {"Group1"}));
+ ASSERT_TRUE(manager.RegisterSource("Source2", {"Group1", "Group2"}));
+
+ ASSERT_FALSE(manager.RegisterSource("Source3", {"Bad"}));
+
+ ASSERT_FALSE(manager.RegisterSource("Source1", {"Group1"}));
+}
+
+TEST_F(PinMuxManagerTest, SetSource) {
+ ASSERT_TRUE(manager.RegisterPin("IO1", true, callbacks));
+ ASSERT_TRUE(manager.RegisterPin("IO2", true, callbacks));
+ ASSERT_TRUE(manager.RegisterPin("IO3", true, callbacks));
+ ASSERT_TRUE(manager.RegisterPin("IO4", true, callbacks));
+
+ ASSERT_TRUE(manager.RegisterPinGroup("Group1", {"IO1", "IO2", "IO3"}));
+ ASSERT_TRUE(manager.RegisterPinGroup("Group2", {"IO4"}));
+
+ ASSERT_TRUE(manager.RegisterSource("Source1", {"Group1", "Group2"}));
+
+ ASSERT_TRUE(manager.SetSource("Source1", "Group1"));
+ ASSERT_TRUE(manager.SetSource("Source1", "Group2"));
+}
+
+// TODO(leecam): Write lots more tetsts :)
+
+} // namespace android
\ No newline at end of file
diff --git a/peripheralmanager/daemon/spi_driver.h b/peripheralmanager/daemon/spi_driver.h
new file mode 100644
index 0000000..44ecc90
--- /dev/null
+++ b/peripheralmanager/daemon/spi_driver.h
@@ -0,0 +1,73 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_DAEMON_SPI_DRIVER_H_
+#define SYSTEM_PERIPHERALMANAGER_DAEMON_SPI_DRIVER_H_
+
+#include <stdint.h>
+
+#include <memory>
+#include <string>
+
+#include <base/macros.h>
+
+#include "peripheralmanager/constants.h"
+
+namespace android {
+
+class SpiDriverInterface {
+ public:
+ SpiDriverInterface() {}
+ virtual ~SpiDriverInterface() {}
+
+ // TODO(leecam): Init should have generic params.
+ virtual bool Init(uint32_t bus_id, uint32_t cs) = 0;
+ virtual bool Transfer(const void* tx_data, void* rx_data, size_t len) = 0;
+ virtual bool SetFrequency(uint32_t speed_hz) = 0;
+ virtual bool SetMode(SpiMode mode) = 0;
+ virtual bool SetBitJustification(bool lsb_first) = 0;
+ virtual bool SetBitsPerWord(uint8_t bits_per_word) = 0;
+ virtual bool SetDelay(uint16_t delay_usecs) = 0;
+};
+
+class SpiDriverInfoBase {
+ public:
+ SpiDriverInfoBase() {}
+ virtual ~SpiDriverInfoBase() {}
+
+ virtual std::string Compat() = 0;
+ virtual std::unique_ptr<SpiDriverInterface> Probe() = 0;
+};
+
+template <class T, class PARAM>
+class SpiDriverInfo : public SpiDriverInfoBase {
+ public:
+ explicit SpiDriverInfo(PARAM param) : param_(param) {}
+ ~SpiDriverInfo() override {}
+
+ std::string Compat() override { return T::Compat(); }
+
+ std::unique_ptr<SpiDriverInterface> Probe() override {
+ return std::unique_ptr<SpiDriverInterface>(new T(param_));
+ }
+
+ private:
+ PARAM param_;
+};
+
+} // namespace android
+
+#endif // SYSTEM_PERIPHERALMANAGER_DAEMON_SPI_DRIVER_H_
diff --git a/peripheralmanager/daemon/spi_driver_spidev.cc b/peripheralmanager/daemon/spi_driver_spidev.cc
new file mode 100644
index 0000000..2ac4844
--- /dev/null
+++ b/peripheralmanager/daemon/spi_driver_spidev.cc
@@ -0,0 +1,172 @@
+/*
+ * 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 "spi_driver_spidev.h"
+
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <linux/spi/spidev.h>
+#include <string>
+
+#include <base/logging.h>
+
+namespace android {
+namespace {
+
+const char kSpiDevPath[] = "/dev/spidev";
+
+} // namespace
+
+SpiDriverSpiDev::SpiDriverSpiDev(CharDeviceFactory* char_device_factory)
+ : fd_(-1), char_device_factory_(char_device_factory) {}
+
+SpiDriverSpiDev::~SpiDriverSpiDev() {
+ if (fd_ >= 0 && char_interface_ != nullptr) {
+ char_interface_->Close(fd_);
+ }
+}
+
+bool SpiDriverSpiDev::Init(uint32_t bus_id, uint32_t cs) {
+ if (fd_ >= 0) {
+ return false;
+ }
+
+ // Get a char device. If char_device_factory_ is set
+ // then this is a unittest and the char device is provided
+ // by the test. Otherwise create a normal CharDevice.
+ if (!char_device_factory_) {
+ char_interface_.reset(new CharDevice());
+ } else {
+ char_interface_ = char_device_factory_->NewCharDevice();
+ }
+
+ std::string path =
+ kSpiDevPath + std::to_string(bus_id) + "." + std::to_string(cs);
+
+ int fd = char_interface_->Open(path.c_str(), O_RDWR);
+ if (fd < 0)
+ return false;
+
+ fd_ = fd;
+
+ // Set the default speed to the max
+ uint32_t max_freq = 0;
+ if (!GetMaxFrequency(&max_freq)) {
+ char_interface_->Close(fd_);
+ fd_ = -1;
+ return false;
+ }
+ speed_hz_ = max_freq;
+
+ // Default to 0 microseconds delay between transfers.
+ delay_usecs_ = 0;
+
+ // Default to 8 bits per word.
+ bits_per_word_ = 8;
+
+ return true;
+}
+
+bool SpiDriverSpiDev::Transfer(const void* tx_data, void* rx_data, size_t len) {
+ struct spi_ioc_transfer msg;
+ memset(&msg, 0, sizeof(msg));
+
+ msg.tx_buf = (unsigned long)tx_data;
+ msg.rx_buf = (unsigned long)rx_data;
+ msg.speed_hz = speed_hz_;
+ msg.bits_per_word = bits_per_word_;
+ msg.delay_usecs = delay_usecs_;
+ msg.len = len;
+
+ if (char_interface_->Ioctl(fd_, SPI_IOC_MESSAGE(1), &msg) < 0) {
+ PLOG(ERROR) << "SPI Transfer IOCTL Failed";
+ return false;
+ }
+ return true;
+}
+
+bool SpiDriverSpiDev::SetFrequency(uint32_t speed_hz) {
+ if (fd_ < 0)
+ return false;
+ // Get the max speed and ensure speed_hz is less than it.
+ uint32_t max_speed = 0;
+ if (!GetMaxFrequency(&max_speed))
+ return false;
+ if (speed_hz > max_speed)
+ speed_hz = max_speed;
+
+ speed_hz_ = speed_hz;
+ return true;
+}
+
+bool SpiDriverSpiDev::GetMaxFrequency(uint32_t* max_freq) {
+ if (char_interface_->Ioctl(fd_, SPI_IOC_RD_MAX_SPEED_HZ, max_freq) < 0) {
+ PLOG(ERROR) << "Failed to get spi max freq";
+ return false;
+ }
+ return true;
+}
+
+bool SpiDriverSpiDev::SetMode(SpiMode mode) {
+ uint8_t k_mode = 0;
+ switch (mode) {
+ case kMode0:
+ k_mode = SPI_MODE_0;
+ break;
+ case kMode1:
+ k_mode = SPI_MODE_1;
+ break;
+ case kMode2:
+ k_mode = SPI_MODE_2;
+ break;
+ case kMode3:
+ k_mode = SPI_MODE_3;
+ break;
+ }
+
+ if (char_interface_->Ioctl(fd_, SPI_IOC_WR_MODE, &k_mode) < 0) {
+ PLOG(ERROR) << "Failed to set mode";
+ return false;
+ }
+
+ return true;
+}
+
+bool SpiDriverSpiDev::SetBitJustification(bool lsb_first) {
+ uint8_t k_lsb_first = lsb_first;
+ if (char_interface_->Ioctl(fd_, SPI_IOC_WR_LSB_FIRST, &k_lsb_first) < 0) {
+ PLOG(ERROR) << "Failed to set bit justifcation";
+ return false;
+ }
+ return true;
+}
+
+bool SpiDriverSpiDev::SetBitsPerWord(uint8_t bits_per_word) {
+ if (char_interface_->Ioctl(fd_, SPI_IOC_WR_BITS_PER_WORD, &bits_per_word) <
+ 0) {
+ PLOG(ERROR) << "Failed to set bits per word";
+ return false;
+ }
+ bits_per_word_ = bits_per_word;
+ return true;
+}
+
+bool SpiDriverSpiDev::SetDelay(uint16_t delay_usecs) {
+ delay_usecs_ = delay_usecs;
+ return true;
+}
+
+} // namespace android
diff --git a/peripheralmanager/daemon/spi_driver_spidev.h b/peripheralmanager/daemon/spi_driver_spidev.h
new file mode 100644
index 0000000..67f3bd5
--- /dev/null
+++ b/peripheralmanager/daemon/spi_driver_spidev.h
@@ -0,0 +1,64 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_DAEMON_SPI_DRIVER_SPIDEV_H_
+#define SYSTEM_PERIPHERALMANAGER_DAEMON_SPI_DRIVER_SPIDEV_H_
+
+#include <stdint.h>
+
+#include <memory>
+
+#include <base/macros.h>
+
+#include "char_device.h"
+#include "spi_driver.h"
+
+namespace android {
+
+class SpiDriverSpiDev : public SpiDriverInterface {
+ public:
+ explicit SpiDriverSpiDev(CharDeviceFactory* char_device_factory);
+ ~SpiDriverSpiDev();
+
+ static std::string Compat() { return "SPIDEV"; }
+
+ bool Init(uint32_t bus_id, uint32_t cs) override;
+ bool Transfer(const void* tx_data, void* rx_data, size_t len) override;
+ bool SetFrequency(uint32_t speed_hz) override;
+ bool SetMode(SpiMode mode) override;
+ bool SetBitJustification(bool lsb_first) override;
+ bool SetBitsPerWord(uint8_t bits_per_word) override;
+ bool SetDelay(uint16_t delay_usecs) override;
+
+ private:
+ bool GetMaxFrequency(uint32_t* max_freq);
+
+ int fd_;
+ uint32_t bits_per_word_;
+ uint32_t speed_hz_;
+ uint16_t delay_usecs_;
+ std::unique_ptr<CharDeviceInterface> char_interface_;
+
+ // Used for unit testing and is null in production.
+ // Ownership is in the test and outlives this class.
+ CharDeviceFactory* char_device_factory_;
+
+ DISALLOW_COPY_AND_ASSIGN(SpiDriverSpiDev);
+};
+
+} // namespace android
+
+#endif // SYSTEM_PERIPHERALMANAGER_DAEMON_SPI_DEVICE_H_
diff --git a/peripheralmanager/daemon/spi_manager.cc b/peripheralmanager/daemon/spi_manager.cc
new file mode 100644
index 0000000..4e11c84
--- /dev/null
+++ b/peripheralmanager/daemon/spi_manager.cc
@@ -0,0 +1,124 @@
+/*
+ * 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 "spi_manager.h"
+
+#include "pin_mux_manager.h"
+
+namespace android {
+
+std::unique_ptr<SpiManager> g_spi_manager;
+
+SpiManager::SpiManager() {}
+
+SpiManager::~SpiManager() {}
+
+// static
+SpiManager* SpiManager::GetSpiManager() {
+ if (!g_spi_manager) {
+ g_spi_manager.reset(new SpiManager());
+ }
+ return g_spi_manager.get();
+}
+
+// static
+void SpiManager::ResetSpiManager() {
+ g_spi_manager.reset();
+}
+
+bool SpiManager::RegisterSpiDevBus(const std::string& name,
+ uint32_t bus,
+ uint32_t cs) {
+ if (spidev_buses_.count(name))
+ return false;
+ spidev_buses_.emplace(name, SpiDevBus(bus, cs));
+ return true;
+}
+
+std::vector<std::string> SpiManager::GetSpiDevBuses() {
+ std::vector<std::string> buses;
+ for (auto& i : spidev_buses_)
+ buses.push_back(i.first);
+ return buses;
+}
+
+bool SpiManager::HasSpiDevBus(const std::string& name) {
+ return spidev_buses_.count(name);
+}
+
+bool SpiManager::RegisterDriver(
+ std::unique_ptr<SpiDriverInfoBase> driver_info) {
+ std::string key = driver_info->Compat();
+ driver_infos_[key] = std::move(driver_info);
+ return true;
+}
+
+bool SpiManager::SetPinMux(const std::string& name, const std::string& mux) {
+ auto bus_it = spidev_buses_.find(name);
+ if (bus_it == spidev_buses_.end())
+ return false;
+ bus_it->second.mux = mux;
+ bus_it->second.mux_group = mux;
+ return true;
+}
+
+bool SpiManager::SetPinMuxWithGroup(const std::string& name,
+ const std::string& mux,
+ const std::string& group) {
+ auto bus_it = spidev_buses_.find(name);
+ if (bus_it == spidev_buses_.end())
+ return false;
+ bus_it->second.mux = mux;
+ bus_it->second.mux_group = group;
+ return true;
+}
+
+std::unique_ptr<SpiDevice> SpiManager::OpenSpiDevice(const std::string& name) {
+ // Get the Bus from the BSP.
+ auto bus_it = spidev_buses_.find(name);
+ if (bus_it == spidev_buses_.end())
+ return nullptr;
+
+ // Check its not alread in use
+ if (bus_it->second.driver_) {
+ return nullptr;
+ }
+
+ // Find a driver.
+ // Currently there is only hardcoded support for SPIDEV
+ auto driver_info_it = driver_infos_.find("SPIDEV");
+
+ // Fail if there is no driver.
+ if (driver_info_it == driver_infos_.end())
+ return nullptr;
+
+ std::unique_ptr<SpiDriverInterface> driver(driver_info_it->second->Probe());
+
+ if (!driver->Init(bus_it->second.bus, bus_it->second.cs))
+ return nullptr;
+
+ // Set Pin muxing.
+ if (!bus_it->second.mux.empty()) {
+ PinMuxManager::GetPinMuxManager()->SetSource(bus_it->second.mux,
+ bus_it->second.mux_group);
+ }
+
+ bus_it->second.driver_ = std::move(driver);
+
+ return std::unique_ptr<SpiDevice>(new SpiDevice(&(bus_it->second)));
+}
+
+} // namespace android
diff --git a/peripheralmanager/daemon/spi_manager.h b/peripheralmanager/daemon/spi_manager.h
new file mode 100644
index 0000000..9ef51e3
--- /dev/null
+++ b/peripheralmanager/daemon/spi_manager.h
@@ -0,0 +1,126 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_DAEMON_SPI_MANAGER_H_
+#define SYSTEM_PERIPHERALMANAGER_DAEMON_SPI_MANAGER_H_
+
+#include <stdint.h>
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <base/macros.h>
+
+#include "peripheralmanager/constants.h"
+#include "pin_mux_manager.h"
+#include "spi_driver.h"
+
+namespace android {
+
+struct SpiDevBus {
+ SpiDevBus(uint32_t b, uint32_t c) : bus(b), cs(c) {}
+ uint32_t bus;
+ uint32_t cs;
+ std::string mux;
+ std::string mux_group;
+ std::unique_ptr<SpiDriverInterface> driver_;
+};
+
+class SpiDevice {
+ public:
+ explicit SpiDevice(SpiDevBus* bus) : bus_(bus) {}
+ ~SpiDevice() {
+ if (!bus_->mux.empty()) {
+ PinMuxManager::GetPinMuxManager()->ReleaseSource(bus_->mux,
+ bus_->mux_group);
+ }
+ bus_->driver_.reset();
+ }
+
+ bool WriteByte(uint8_t val) { return Transfer(&val, nullptr, sizeof(val)); }
+
+ bool WriteBuffer(const void* data, size_t len) {
+ return Transfer(data, nullptr, len);
+ }
+
+ bool Transfer(const void* tx_data, void* rx_data, size_t len) {
+ return bus_->driver_->Transfer(tx_data, rx_data, len);
+ }
+
+ bool SetFrequency(uint32_t speed_hz) {
+ return bus_->driver_->SetFrequency(speed_hz);
+ }
+
+ bool SetMode(SpiMode mode) { return bus_->driver_->SetMode(mode); }
+
+ bool SetBitJustification(bool lsb_first) {
+ return bus_->driver_->SetBitJustification(lsb_first);
+ }
+
+ bool SetBitsPerWord(uint8_t bits_per_word) {
+ return bus_->driver_->SetBitsPerWord(bits_per_word);
+ }
+
+ bool SetDelay(uint16_t delay_usecs) {
+ return bus_->driver_->SetDelay(delay_usecs);
+ }
+
+ private:
+ SpiDevBus* bus_;
+};
+
+class SpiManager {
+ public:
+ friend class SpiManagerTest;
+ ~SpiManager();
+
+ // Get the singleton.
+ static SpiManager* GetSpiManager();
+
+ // Reset the Spi manager.
+ static void ResetSpiManager();
+
+ // Used by the BSP to tell PMan of an SPI bus
+ // 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> GetSpiDevBuses();
+ bool HasSpiDevBus(const std::string& name);
+
+ bool SetPinMux(const std::string& name, const std::string& mux);
+ bool SetPinMuxWithGroup(const std::string& name,
+ const std::string& mux,
+ const std::string& group);
+
+ bool RegisterDriver(std::unique_ptr<SpiDriverInfoBase> driver_info);
+
+ std::unique_ptr<SpiDevice> OpenSpiDevice(const std::string& name);
+
+ private:
+ SpiManager();
+
+ std::map<std::string, std::unique_ptr<SpiDriverInfoBase>> driver_infos_;
+ std::map<std::string, SpiDevBus> spidev_buses_;
+
+ DISALLOW_COPY_AND_ASSIGN(SpiManager);
+};
+
+} // namespace android
+
+#endif // SYSTEM_PERIPHERALMANAGER_DAEMON_SPI_MANAGER_H_
diff --git a/peripheralmanager/daemon/spi_manager_unittest.cc b/peripheralmanager/daemon/spi_manager_unittest.cc
new file mode 100644
index 0000000..924b014
--- /dev/null
+++ b/peripheralmanager/daemon/spi_manager_unittest.cc
@@ -0,0 +1,67 @@
+/*
+ * 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 <stdio.h>
+
+#include <gtest/gtest.h>
+
+#include "fake_devices.h"
+#include "spi_manager.h"
+#include "spi_driver_spidev.h"
+
+namespace android {
+
+class SpiManagerTest : public ::testing::Test {
+ public:
+ SpiManagerTest() {
+ manager.RegisterDriver(std::unique_ptr<SpiDriverInfoBase>(
+ new SpiDriverInfo<SpiDriverSpiDev, CharDeviceFactory*>(
+ &device_factory)));
+ }
+ ~SpiManagerTest() = default;
+
+ protected:
+ FakeDeviceFactory device_factory;
+ SpiManager manager;
+};
+
+TEST_F(SpiManagerTest, SimpleRegister) {
+ manager.RegisterSpiDevBus("SPI0_1", 0, 1);
+ std::vector<std::string> busses = manager.GetSpiDevBuses();
+ ASSERT_EQ(1U, busses.size());
+ ASSERT_EQ("SPI0_1", busses[0]);
+}
+
+TEST_F(SpiManagerTest, SimpleOpen) {
+ manager.RegisterSpiDevBus("SPI0_1", 0, 1);
+ std::unique_ptr<SpiDevice> device(manager.OpenSpiDevice("SPI0_1"));
+ ASSERT_NE(nullptr, device);
+ std::unique_ptr<SpiDevice> device2(manager.OpenSpiDevice("SPI0_1"));
+ ASSERT_EQ(nullptr, device2);
+ device.reset();
+ std::unique_ptr<SpiDevice> device3(manager.OpenSpiDevice("SPI0_1"));
+ ASSERT_NE(nullptr, device3);
+}
+
+TEST_F(SpiManagerTest, SetFrequency) {
+ manager.RegisterSpiDevBus("SPI0_1", 0, 1);
+ std::unique_ptr<SpiDevice> device(manager.OpenSpiDevice("SPI0_1"));
+ ASSERT_NE(nullptr, device);
+
+ device->SetFrequency(100);
+}
+
+} // namespace android
diff --git a/peripheralmanager/daemon/uart_driver.h b/peripheralmanager/daemon/uart_driver.h
new file mode 100644
index 0000000..e8d7ed7
--- /dev/null
+++ b/peripheralmanager/daemon/uart_driver.h
@@ -0,0 +1,73 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_DAEMON_UART_DRIVER_H_
+#define SYSTEM_PERIPHERALMANAGER_DAEMON_UART_DRIVER_H_
+
+#include <stdint.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <base/macros.h>
+
+namespace android {
+
+class UartDriverInterface {
+ public:
+ virtual ~UartDriverInterface() {}
+
+ // TODO(leecam): Init should have generic params.
+ virtual bool Init(const std::string& name) = 0;
+
+ virtual int SetBaudrate(uint32_t baudrate) = 0;
+
+ virtual int Write(const std::vector<uint8_t>& data,
+ uint32_t* bytes_written) = 0;
+
+ virtual int Read(std::vector<uint8_t>* data,
+ uint32_t size,
+ uint32_t* bytes_read) = 0;
+};
+
+class UartDriverInfoBase {
+ public:
+ virtual ~UartDriverInfoBase() {}
+
+ virtual std::string Compat() = 0;
+ virtual std::unique_ptr<UartDriverInterface> Probe() = 0;
+};
+
+template <class T, class PARAM>
+class UartDriverInfo : public UartDriverInfoBase {
+ public:
+ explicit UartDriverInfo(PARAM param) : param_(param) {}
+ ~UartDriverInfo() override {}
+
+ std::string Compat() override { return T::Compat(); }
+
+ std::unique_ptr<UartDriverInterface> Probe() override {
+ return std::unique_ptr<UartDriverInterface>(new T(param_));
+ }
+
+ private:
+ PARAM param_;
+};
+
+} // namespace android
+
+#endif // SYSTEM_PERIPHERALMANAGER_DAEMON_UART_DRIVER_H_
diff --git a/peripheralmanager/daemon/uart_driver_sysfs.cc b/peripheralmanager/daemon/uart_driver_sysfs.cc
new file mode 100644
index 0000000..41e3064
--- /dev/null
+++ b/peripheralmanager/daemon/uart_driver_sysfs.cc
@@ -0,0 +1,204 @@
+/*
+ * 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 "uart_driver_sysfs.h"
+
+#include <fcntl.h>
+#include <termios.h>
+
+#include <base/logging.h>
+
+#include "char_device.h"
+
+namespace android {
+
+UartDriverSysfs::UartDriverSysfs(CharDeviceFactory* factory)
+ : char_device_factory_(factory) {}
+
+UartDriverSysfs::~UartDriverSysfs() {}
+
+bool UartDriverSysfs::Init(const std::string& name) {
+ path_ = name;
+
+ // Get a char device. If char_device_factory_ is set
+ // then this is a unittest and the char device is provided
+ // by the test. Otherwise create a normal CharDevice.
+ if (!char_device_factory_) {
+ char_interface_.reset(new CharDevice());
+ } else {
+ char_interface_ = char_device_factory_->NewCharDevice();
+ }
+
+ // Open as non-blocking as we don't want peripheral_manager to block on a
+ // single client read.
+ int fd = char_interface_->Open(path_.c_str(), O_RDWR | O_NONBLOCK);
+ if (fd < 0) {
+ PLOG(WARNING) << "Failed to open " << path_;
+ return false;
+ }
+
+ // Configure the device in raw mode.
+ struct termios config;
+ if (char_interface_->Ioctl(fd, TCGETS, &config)) {
+ PLOG(ERROR) << "Failed to read the tty config";
+ close(fd);
+ return false;
+ }
+ cfmakeraw(&config);
+
+ if (char_interface_->Ioctl(fd, TCSETSF, &config)) {
+ PLOG(ERROR) << "Failed to configure the UART device as Raw.";
+ close(fd);
+ return false;
+ }
+
+ fd_ = fd;
+ return true;
+}
+
+int UartDriverSysfs::SetBaudrate(uint32_t baudrate) {
+ speed_t s;
+ switch (baudrate) {
+ case 0:
+ s = B0;
+ break;
+
+ case 50:
+ s = B50;
+ break;
+
+ case 75:
+ s = B75;
+ break;
+
+ case 110:
+ s = B110;
+ break;
+
+ case 134:
+ s = B134;
+ break;
+
+ case 150:
+ s = B150;
+ break;
+
+ case 200:
+ s = B200;
+ break;
+
+ case 300:
+ s = B300;
+ break;
+
+ case 600:
+ s = B600;
+ break;
+
+ case 1200:
+ s = B1200;
+ break;
+
+ case 1800:
+ s = B1800;
+ break;
+
+ case 2400:
+ s = B2400;
+ break;
+
+ case 4800:
+ s = B4800;
+ break;
+
+ case 9600:
+ s = B9600;
+ break;
+
+ case 19200:
+ s = B19200;
+ break;
+
+ case 38400:
+ s = B38400;
+ break;
+
+ case 57600:
+ s = B57600;
+ break;
+
+ case 115200:
+ s = B115200;
+ break;
+
+ case 230400:
+ s = B230400;
+ break;
+ default:
+ return EINVAL;
+ }
+
+ struct termios config;
+
+ if (char_interface_->Ioctl(fd_, TCGETS, &config) != 0 ||
+ cfsetspeed(&config, s) != 0 ||
+ char_interface_->Ioctl(fd_, TCSETS, &config) != 0) {
+ LOG(ERROR) << "Failed to set the UART baurate to " << baudrate;
+ return EIO;
+ }
+
+ return 0;
+}
+
+int UartDriverSysfs::Write(const std::vector<uint8_t>& data,
+ uint32_t* bytes_written) {
+ errno = 0;
+ int ret = char_interface_->Write(fd_, data.data(), data.size());
+
+ if (ret == -1) {
+ PLOG(ERROR) << "Failed to write to UART device";
+ *bytes_written = 0;
+ return EIO;
+ }
+
+ *bytes_written = ret;
+ return 0;
+}
+
+int UartDriverSysfs::Read(std::vector<uint8_t>* data,
+ uint32_t size,
+ uint32_t* bytes_read) {
+ errno = 0;
+ data->resize(size);
+
+ int ret = char_interface_->Read(fd_, data->data(), size);
+
+ if (ret == -1) {
+ *bytes_read = 0;
+ data->resize(0);
+ if (errno == EAGAIN) {
+ return EAGAIN;
+ }
+ PLOG(ERROR) << "Failed to read from UART device";
+ return EIO;
+ }
+
+ *bytes_read = ret;
+ data->resize(ret);
+ return 0;
+}
+
+} // namespace android
diff --git a/peripheralmanager/daemon/uart_driver_sysfs.h b/peripheralmanager/daemon/uart_driver_sysfs.h
new file mode 100644
index 0000000..35085b7
--- /dev/null
+++ b/peripheralmanager/daemon/uart_driver_sysfs.h
@@ -0,0 +1,58 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_DAEMON_UART_DRIVER_SYSFS_H_
+#define SYSTEM_PERIPHERALMANAGER_DAEMON_UART_DRIVER_SYSFS_H_
+
+#include <stdint.h>
+
+#include <base/macros.h>
+
+#include "char_device.h"
+#include "uart_driver.h"
+
+namespace android {
+
+class UartDriverSysfs : public UartDriverInterface {
+ public:
+ explicit UartDriverSysfs(CharDeviceFactory* factory);
+ ~UartDriverSysfs();
+
+ static std::string Compat() { return "UARTSYSFS"; }
+
+ bool Init(const std::string& name) override;
+
+ int SetBaudrate(uint32_t baudrate) override;
+
+ int Write(const std::vector<uint8_t>& data, uint32_t* bytes_written) override;
+
+ int Read(std::vector<uint8_t>* data,
+ uint32_t size,
+ uint32_t* bytes_read) override;
+
+ private:
+ int fd_;
+ std::string path_;
+
+ CharDeviceFactory* char_device_factory_;
+ std::unique_ptr<CharDeviceInterface> char_interface_;
+
+ DISALLOW_COPY_AND_ASSIGN(UartDriverSysfs);
+};
+
+} // namespace android
+
+#endif // SYSTEM_PERIPHERALMANAGER_DAEMON_UART_DRIVER_SYSFS_H_
diff --git a/peripheralmanager/daemon/uart_manager.cc b/peripheralmanager/daemon/uart_manager.cc
new file mode 100644
index 0000000..bc98111
--- /dev/null
+++ b/peripheralmanager/daemon/uart_manager.cc
@@ -0,0 +1,119 @@
+/*
+ * 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 "uart_manager.h"
+
+#include "uart_driver_sysfs.h"
+
+#include <base/logging.h>
+
+namespace android {
+
+std::unique_ptr<UartManager> g_uart_manager;
+
+UartManager* UartManager::GetManager() {
+ if (!g_uart_manager) {
+ g_uart_manager.reset(new UartManager);
+ }
+ return g_uart_manager.get();
+}
+
+void UartManager::ResetManager() {
+ g_uart_manager.reset();
+}
+
+UartManager::UartManager() {}
+
+UartManager::~UartManager() {}
+
+bool UartManager::RegisterDriver(
+ std::unique_ptr<UartDriverInfoBase> driver_info) {
+ std::string key = driver_info->Compat();
+ driver_infos_[key] = std::move(driver_info);
+ return true;
+}
+
+bool UartManager::RegisterUartDevice(const std::string& name,
+ const std::string& uart_device_name) {
+ if (uart_devices_.count(name)) {
+ LOG(ERROR) << "Uart device " << name << " is already registered";
+ return false;
+ }
+ uart_devices_[name].name = name;
+ uart_devices_[name].path = uart_device_name;
+ return true;
+}
+
+bool UartManager::SetPinMux(const std::string& name,
+ const std::string& pin_mux) {
+ auto bus_it = uart_devices_.find(name);
+ if (bus_it == uart_devices_.end()) {
+ LOG(ERROR) << "Uart device " << name << " is not registered";
+ return false;
+ }
+
+ bus_it->second.mux = pin_mux;
+ return true;
+}
+
+std::vector<std::string> UartManager::GetDevicesList() {
+ std::vector<std::string> list;
+ for (const auto& it : uart_devices_) {
+ list.push_back(it.first);
+ }
+ return list;
+}
+
+bool UartManager::HasUartDevice(const std::string& name) {
+ return uart_devices_.count(name);
+}
+
+std::unique_ptr<UartDevice> UartManager::OpenUartDevice(
+ const std::string& name) {
+ // Get the Bus from the BSP.
+ auto bus_it = uart_devices_.find(name);
+ if (bus_it == uart_devices_.end())
+ return nullptr;
+
+ // Check its not already in use
+ if (bus_it->second.driver_)
+ return nullptr;
+
+ // Find a driver.
+ // Currently there is only hardcoded support for UARTSYSFS
+ auto driver_info_it = driver_infos_.find(UartDriverSysfs::Compat());
+
+ // Fail if there is no driver.
+ if (driver_info_it == driver_infos_.end())
+ return nullptr;
+
+ std::unique_ptr<UartDriverInterface> driver(driver_info_it->second->Probe());
+
+ if (!driver->Init(bus_it->second.path))
+ return nullptr;
+
+ // Set Pin muxing.
+ if (!bus_it->second.mux.empty()) {
+ PinMuxManager::GetPinMuxManager()->SetSource(bus_it->second.mux,
+ bus_it->second.mux);
+ }
+
+ bus_it->second.driver_ = std::move(driver);
+
+ return std::unique_ptr<UartDevice>(new UartDevice(&(bus_it->second)));
+}
+
+} // namespace android
diff --git a/peripheralmanager/daemon/uart_manager.h b/peripheralmanager/daemon/uart_manager.h
new file mode 100644
index 0000000..ba8fa51
--- /dev/null
+++ b/peripheralmanager/daemon/uart_manager.h
@@ -0,0 +1,92 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_DAEMON_UART_MANAGER_H_
+#define SYSTEM_PERIPHERALMANAGER_DAEMON_UART_MANAGER_H_
+
+#include <stdint.h>
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <base/macros.h>
+
+#include "pin_mux_manager.h"
+#include "uart_driver.h"
+
+namespace android {
+
+struct UartSysfs {
+ std::string name;
+ std::string path;
+ std::string mux;
+ std::unique_ptr<UartDriverInterface> driver_;
+};
+
+class UartDevice {
+ public:
+ explicit UartDevice(UartSysfs* uart_device) : uart_device_(uart_device) {}
+ ~UartDevice() { uart_device_->driver_.reset(); }
+
+ int SetBaudrate(uint32_t baudrate) {
+ return uart_device_->driver_->SetBaudrate(baudrate);
+ }
+
+ int Write(const std::vector<uint8_t>& data, uint32_t* bytes_written) {
+ return uart_device_->driver_->Write(data, bytes_written);
+ }
+
+ int Read(std::vector<uint8_t>* data, uint32_t size, uint32_t* bytes_read) {
+ return uart_device_->driver_->Read(data, size, bytes_read);
+ }
+
+ private:
+ UartSysfs* uart_device_;
+};
+
+class UartManager {
+ public:
+ ~UartManager();
+
+ // Get the singleton.
+ static UartManager* GetManager();
+ static void ResetManager();
+
+ // Used by the BSP to tell PMan of an sysfs uart_device.
+ bool RegisterUartDevice(const std::string& name, const std::string& path);
+ bool SetPinMux(const std::string& name, const std::string& mux);
+
+ std::vector<std::string> GetDevicesList();
+ bool HasUartDevice(const std::string& name);
+
+ bool RegisterDriver(std::unique_ptr<UartDriverInfoBase> driver_info);
+
+ std::unique_ptr<UartDevice> OpenUartDevice(const std::string& name);
+
+ private:
+ UartManager();
+
+ std::map<std::string, std::unique_ptr<UartDriverInfoBase>> driver_infos_;
+ std::map<std::string, UartSysfs> uart_devices_;
+
+ DISALLOW_COPY_AND_ASSIGN(UartManager);
+};
+
+} // namespace android
+
+#endif // SYSTEM_PERIPHERALMANAGER_DAEMON_UART_MANAGER_H_
diff --git a/peripheralmanager/example/Android.mk b/peripheralmanager/example/Android.mk
new file mode 100644
index 0000000..a4099fb
--- /dev/null
+++ b/peripheralmanager/example/Android.mk
@@ -0,0 +1,147 @@
+#
+# Copyright (C) 2015 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.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+# Flips a GPIO on and off.
+# ========================================================
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := peripheralman_gpio_flip
+LOCAL_CPP_EXTENSION := .cc
+LOCAL_CFLAGS := -Wall -Werror -Wno-unused-parameter
+LOCAL_CFLAGS += -Wno-sign-promo # for libchrome
+LOCAL_SHARED_LIBRARIES := \
+ libbrillo \
+ libchrome \
+ libperipheralman \
+ libutils \
+
+LOCAL_SRC_FILES := \
+ gpio_flip_example.cc \
+
+include $(BUILD_EXECUTABLE)
+
+# Watches the state of a gpio with interrupts.
+# ========================================================
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := peripheralman_gpio_interrupt
+LOCAL_CPP_EXTENSION := .cc
+LOCAL_CFLAGS := -Wall -Werror -Wno-unused-parameter
+LOCAL_CFLAGS += -Wno-sign-promo # for libchrome
+LOCAL_SHARED_LIBRARIES := \
+ libbrillo \
+ libchrome \
+ libperipheralman \
+ libutils \
+
+LOCAL_SRC_FILES := \
+ gpio_interrupt_example.cc \
+
+include $(BUILD_EXECUTABLE)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := pio_flash_apa10c
+LOCAL_CPP_EXTENSION := .cc
+LOCAL_CFLAGS := -Wall -Werror -Wno-unused-parameter
+LOCAL_CFLAGS += -Wno-sign-promo # for libchrome
+LOCAL_SHARED_LIBRARIES := \
+ libbrillo \
+ libchrome \
+ libperipheralman \
+ libutils \
+
+LOCAL_SRC_FILES := \
+ pio_flash_apa10c.cc \
+
+include $(BUILD_EXECUTABLE)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := peripheralman_blink_led
+LOCAL_CPP_EXTENSION := .cc
+LOCAL_CFLAGS := -Wall -Werror -Wno-unused-parameter
+LOCAL_CFLAGS += -Wno-sign-promo # for libchrome
+LOCAL_SHARED_LIBRARIES := \
+ libbrillo \
+ libchrome \
+ libperipheralman \
+ libutils \
+
+LOCAL_SRC_FILES := \
+ led_example.cc \
+
+include $(BUILD_EXECUTABLE)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := pio_mcp9808
+LOCAL_CPP_EXTENSION := .cc
+LOCAL_CFLAGS := -Wall -Werror -Wno-unused-parameter
+LOCAL_CFLAGS += -Wno-sign-promo # for libchrome
+LOCAL_SHARED_LIBRARIES := \
+ libbrillo \
+ libchrome \
+ libperipheralman \
+ libutils \
+
+LOCAL_SRC_FILES := \
+ pio_mcp9808.cc \
+
+include $(BUILD_EXECUTABLE)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := pio_gy521
+LOCAL_CPP_EXTENSION := .cc
+LOCAL_CFLAGS := -Wall -Werror -Wno-unused-parameter
+LOCAL_CFLAGS += -Wno-sign-promo # for libchrome
+LOCAL_SHARED_LIBRARIES := \
+ libbrillo \
+ libchrome \
+ libperipheralman \
+ libutils \
+
+LOCAL_SRC_FILES := \
+ pio_gy521.cc \
+
+include $(BUILD_EXECUTABLE)
+
+# Check that headers are C89 compatible.
+include $(CLEAR_VARS)
+LOCAL_MODULE := compatibility_test
+LOCAL_CFLAGS := -Wall -Wextra -std=c89 -pedantic -Wmissing-prototypes \
+ -Wstrict-prototypes -Wold-style-definition -Wno-comment
+
+LOCAL_SHARED_LIBRARIES := libperipheralman
+LOCAL_STATIC_LIBRARIES := peripheral_manager_hal_headers
+
+LOCAL_SRC_FILES := headers_are_c89.c
+include $(BUILD_STATIC_LIBRARY)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := pio_uart
+LOCAL_CPP_EXTENSION := .cc
+LOCAL_CFLAGS := -Wall -Werror -Wno-unused-parameter
+LOCAL_CFLAGS += -Wno-sign-promo # for libchrome
+LOCAL_SHARED_LIBRARIES := \
+ libbrillo \
+ libchrome \
+ libperipheralman \
+ libutils \
+
+LOCAL_SRC_FILES := \
+ pio_uart.cc \
+
+include $(BUILD_EXECUTABLE)
diff --git a/peripheralmanager/example/gpio_flip_example.cc b/peripheralmanager/example/gpio_flip_example.cc
new file mode 100644
index 0000000..6c6b267
--- /dev/null
+++ b/peripheralmanager/example/gpio_flip_example.cc
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2015 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 <unistd.h>
+
+#include <memory>
+
+#include <base/logging.h>
+#include <brillo/flag_helper.h>
+
+#include <peripheralmanager/peripheral_manager_client.h>
+
+int main(int argc, char* argv[]) {
+ DEFINE_string(pin, "", "Pin to toggle");
+ brillo::FlagHelper::Init(argc, argv, "Example PeripheralManager client.");
+ logging::InitLogging(logging::LoggingSettings());
+
+ std::string pin_name = "IO13";
+ if (!FLAGS_pin.empty())
+ pin_name = FLAGS_pin;
+
+ LOG(INFO) << "Toggling Pin " << pin_name;
+
+ // Get a client to the PeripheralManager.
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+
+ if (!client) {
+ LOG(ERROR) << "Failed to connect to client";
+ return 1;
+ }
+
+ // Open GPIO pin.
+ BGpio* my_gpio;
+ int ret =
+ BPeripheralManagerClient_openGpio(client, pin_name.c_str(), &my_gpio);
+ if (ret) {
+ LOG(ERROR) << "Failed to open Gpio: " << strerror(ret);
+ return 1;
+ }
+
+ // Set the direction to out.
+ ret = BGpio_setDirection(my_gpio, DIRECTION_OUT_INITIALLY_HIGH);
+ if (ret) {
+ LOG(ERROR) << "Failed to set gpio pin direction: " << strerror(ret);
+ return 1;
+ }
+
+ // Toggle the output.
+ BGpio_setValue(my_gpio, 0);
+ sleep(1);
+ BGpio_setValue(my_gpio, 1);
+
+ // Release the gpio pin
+ BGpio_delete(my_gpio);
+
+ // Close the connection to PeripheralManager.
+ BPeripheralManagerClient_delete(client);
+
+ LOG(INFO) << "Exiting";
+ return 0;
+}
diff --git a/peripheralmanager/example/gpio_interrupt_example.cc b/peripheralmanager/example/gpio_interrupt_example.cc
new file mode 100644
index 0000000..3261f81
--- /dev/null
+++ b/peripheralmanager/example/gpio_interrupt_example.cc
@@ -0,0 +1,108 @@
+/*
+ * 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 <poll.h>
+#include <sys/select.h>
+#include <unistd.h>
+
+#include <memory>
+
+#include <base/logging.h>
+#include <brillo/flag_helper.h>
+
+#include <peripheralmanager/peripheral_manager_client.h>
+
+int main(int argc, char* argv[]) {
+ DEFINE_string(pin, "", "Pin to watch");
+ DEFINE_bool(select, false, "Use select instead of poll");
+ brillo::FlagHelper::Init(argc, argv, "Watches a GPIO.");
+ logging::InitLogging(logging::LoggingSettings());
+
+ std::string pin_name = "IO1";
+ if (!FLAGS_pin.empty())
+ pin_name = FLAGS_pin;
+
+ // Get a client to the PeripheralManager.
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+
+ if (!client) {
+ LOG(ERROR) << "Failed to connect to client";
+ return 1;
+ }
+
+ // Open GPIO pin.
+ BGpio* my_gpio;
+ if (BPeripheralManagerClient_openGpio(client, pin_name.c_str(), &my_gpio)) {
+ LOG(ERROR) << "Failed to open Gpio";
+ return 1;
+ }
+
+ // Set the direction to in.
+ if (BGpio_setDirection(my_gpio, DIRECTION_IN)) {
+ LOG(ERROR) << "Failed to set gpio pin direction";
+ return 1;
+ }
+
+ // Set the edge trigger type for interrupts.
+ if (BGpio_setEdgeTriggerType(my_gpio, BOTH_EDGE)) {
+ LOG(ERROR) << "failed to set the edge type";
+ return 1;
+ }
+
+ // Get the file descriptor used to poll for data.
+ int fd = -1;
+ if (BGpio_getPollingFd(my_gpio, &fd)) {
+ LOG(ERROR) << "failed to get the fd";
+ return 1;
+ }
+
+ if (FLAGS_select) {
+ fd_set ifds;
+ FD_ZERO(&ifds);
+ FD_SET(fd, &ifds);
+
+ for (int i = 0; i < 30; i++) {
+ select(fd + 1, NULL, NULL, &ifds, NULL);
+ LOG(INFO) << "received event";
+ BGpio_ackInterruptEvent(fd);
+ }
+ } else {
+ struct pollfd poller = {
+ .fd = fd,
+ .events = POLLPRI | POLLERR,
+ .revents = 0,
+ };
+
+ for (int i = 0; i < 30; i++) {
+ // Poll with no timeout.
+ poll(&poller, 1, -1);
+ LOG(INFO) << "received an event ";
+ BGpio_ackInterruptEvent(fd);
+ poller.revents = 0;
+ }
+ }
+
+ close(fd);
+
+ // Release the gpio pin
+ BGpio_delete(my_gpio);
+
+ // Close the connection to PeripheralManager.
+ BPeripheralManagerClient_delete(client);
+
+ LOG(INFO) << "Exiting";
+ return 0;
+}
diff --git a/peripheralmanager/example/headers_are_c89.c b/peripheralmanager/example/headers_are_c89.c
new file mode 100644
index 0000000..ff13b4d
--- /dev/null
+++ b/peripheralmanager/example/headers_are_c89.c
@@ -0,0 +1,18 @@
+/*
+ * 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 "hardware/peripheral_io.h"
+#include "peripheralmanager/peripheral_manager_client.h"
diff --git a/peripheralmanager/example/led_example.cc b/peripheralmanager/example/led_example.cc
new file mode 100644
index 0000000..ab5c7b3
--- /dev/null
+++ b/peripheralmanager/example/led_example.cc
@@ -0,0 +1,95 @@
+/*
+ * 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 <unistd.h>
+
+#include <memory>
+
+#include <base/logging.h>
+#include <brillo/flag_helper.h>
+
+#include <peripheralmanager/peripheral_manager_client.h>
+
+int main(int argc, char* argv[]) {
+ DEFINE_string(led, "", "Led to toggle");
+ brillo::FlagHelper::Init(argc, argv, "Example client blinking a light.");
+ logging::InitLogging(logging::LoggingSettings());
+
+ if (FLAGS_led.empty()) {
+ LOG(ERROR) << "Led name not specified.";
+ return 1;
+ }
+
+ LOG(INFO) << "Blinking " << FLAGS_led;
+
+ // Get a client to the PeripheralManager.
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+
+ if (!client) {
+ LOG(ERROR) << "Failed to connect to client";
+ return 1;
+ }
+
+ // Open the LED.
+ BLed* led;
+ int ret = BPeripheralManagerClient_openLed(client, FLAGS_led.c_str(), &led);
+ if (ret) {
+ LOG(ERROR) << "Failed to open LED: " << strerror(ret);
+ return 1;
+ }
+
+ uint32_t max_brightness = 0;
+
+ // Get the maximum brightness possible.
+ ret = BLed_getMaxBrightness(led, &max_brightness);
+ if (ret) {
+ LOG(ERROR) << "Failed to get the maximum brightness: " << strerror(ret);
+ return 1;
+ }
+
+ // Toggle the output.
+ BLed_setBrightness(led, 0);
+ sleep(1);
+ BLed_setBrightness(led, max_brightness / 2);
+ sleep(1);
+ BLed_setBrightness(led, max_brightness);
+ sleep(1);
+ BLed_setBrightness(led, max_brightness / 2);
+ sleep(1);
+ BLed_setBrightness(led, 0);
+
+ // Make sure the led is turned off.
+ uint32_t brightness;
+ ret = BLed_getBrightness(led, &brightness);
+ if (ret) {
+ LOG(ERROR) << "Failed to read the brightness: " << strerror(ret);
+ return 1;
+ }
+
+ if (brightness != 0) {
+ LOG(ERROR) << "Failed to turn the LED off, led is at: "
+ << std::to_string(brightness);
+ }
+
+ // Release the LED
+ BLed_delete(led);
+
+ // Close the connection to PeripheralManager.
+ BPeripheralManagerClient_delete(client);
+
+ LOG(INFO) << "Exiting";
+ return 0;
+}
diff --git a/peripheralmanager/example/pio_flash_apa10c.cc b/peripheralmanager/example/pio_flash_apa10c.cc
new file mode 100644
index 0000000..82dfa33
--- /dev/null
+++ b/peripheralmanager/example/pio_flash_apa10c.cc
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2015 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 <unistd.h>
+
+#include <memory>
+
+#include <base/logging.h>
+#include <brillo/flag_helper.h>
+
+#include <peripheralmanager/peripheral_manager_client.h>
+
+void SetLed(const BSpiDevice* my_spi, uint8_t r, uint8_t g, uint8_t b) {
+ uint8_t start_frame[] = {0x00, 0x00, 0x00, 0x00};
+ uint8_t on_frame[4] = {0xff, 0x00, 0x00, 0x00};
+ uint8_t end_frame[] = {0xff, 0xff, 0xff, 0xff};
+ on_frame[1] = b;
+ on_frame[2] = g;
+ on_frame[3] = r;
+ BSpiDevice_writeBuffer(my_spi, start_frame, sizeof(start_frame));
+ BSpiDevice_writeBuffer(my_spi, on_frame, sizeof(on_frame));
+ BSpiDevice_writeBuffer(my_spi, end_frame, sizeof(end_frame));
+}
+
+int main(int argc, char* argv[]) {
+ brillo::FlagHelper::Init(argc, argv, "PeripheralManager client.");
+ logging::InitLogging(logging::LoggingSettings());
+
+ LOG(INFO) << "PeripheralManager Client";
+
+ // Get a client to the PeripheralManager.
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+
+ if (!client) {
+ LOG(ERROR) << "Failed to connect to client";
+ return 1;
+ }
+
+ // Open SPI bus.
+ BSpiDevice* my_spi;
+ int ret = BPeripheralManagerClient_openSpiDevice(client, "SPI2", &my_spi);
+ if (ret) {
+ LOG(ERROR) << "Failed to open Spi: " << strerror(ret);
+ return 1;
+ }
+
+ BSpiDevice_setFrequency(my_spi, 400000);
+
+ SetLed(my_spi, 0xff, 0x0, 0x0);
+ sleep(1);
+ SetLed(my_spi, 0x00, 0xff, 0x0);
+ sleep(1);
+ SetLed(my_spi, 0x00, 0x0, 0xff);
+ sleep(1);
+
+ BSpiDevice_delete(my_spi);
+
+ // Close the connection to PeripheralManager.
+ BPeripheralManagerClient_delete(client);
+
+ LOG(INFO) << "Exiting";
+ return 0;
+}
diff --git a/peripheralmanager/example/pio_gy521.cc b/peripheralmanager/example/pio_gy521.cc
new file mode 100644
index 0000000..ec9296f
--- /dev/null
+++ b/peripheralmanager/example/pio_gy521.cc
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2015 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 <arpa/inet.h>
+#include <unistd.h>
+
+#include <memory>
+
+#include <base/logging.h>
+#include <brillo/flag_helper.h>
+
+#include <peripheralmanager/peripheral_manager_client.h>
+
+int16_t swap_bytes(int16_t i) {
+ return ((i & 0x00FF) << 8) + ((i & 0xFF00) >> 8);
+}
+
+int main(int argc, char* argv[]) {
+ brillo::FlagHelper::Init(argc, argv, "PeripheralManager example.");
+ logging::InitLogging(logging::LoggingSettings());
+
+ // Get a client to the PeripheralManager.
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+
+ if (!client) {
+ LOG(ERROR) << "Failed to connect to client";
+ return 1;
+ }
+
+ // Open I2C device.
+ BI2cDevice* i2c_device;
+ int ret =
+ BPeripheralManagerClient_openI2cDevice(client, "I2C6", 0x68, &i2c_device);
+ if (ret) {
+ LOG(ERROR) << "Failed to open I2C: " << strerror(ret);
+ return 1;
+ }
+
+ // Turn the sensor on.
+ ret = BI2cDevice_writeRegByte(i2c_device, 0x6B, 0);
+ if (ret) {
+ LOG(ERROR) << "Failed to setup the device: " << strerror(ret);
+ return 1;
+ }
+
+ // Read the "who am I" register (contains the device address).
+ uint8_t address;
+ ret = BI2cDevice_readRegByte(i2c_device, 0x75, &address);
+ if (ret) {
+ LOG(ERROR) << "Failed to read the WHO AM I register: " << strerror(ret);
+ return 1;
+ }
+ printf("I am at address is: 0x%X\n", address);
+
+ int16_t temp = 0;
+ ret = BI2cDevice_readRegWord(
+ i2c_device, 0x41, reinterpret_cast<uint16_t*>(&temp));
+ if (ret) {
+ LOG(ERROR) << "Failed to read the temp: " << strerror(ret);
+ return 1;
+ }
+ temp = ntohs(temp);
+ float t = temp;
+ printf("temp is: %.02f degrees Celsius.\n", t / 340 + 36.53);
+
+ for (int j = 0; j < 50; j++) {
+
+ // Read the values of the accelerometer.
+ int16_t accel_data[3];
+
+ uint32_t read;
+ ret = BI2cDevice_readRegBuffer(i2c_device, 0x3B, &accel_data, 6, &read);
+ if (ret || read != 6) {
+ LOG(ERROR) << "Failed to read the buffer: " << strerror(ret);
+ return 1;
+ }
+
+ printf("Accelerometer values: X=%i, Y=%i, Z=%i\n",
+ swap_bytes(accel_data[0]),
+ swap_bytes(accel_data[1]),
+ swap_bytes(accel_data[2]));
+
+ sleep(1);
+ }
+
+ BI2cDevice_delete(i2c_device);
+
+ // Close the connection to PeripheralManager.
+ BPeripheralManagerClient_delete(client);
+
+ return 0;
+}
diff --git a/peripheralmanager/example/pio_mcp9808.cc b/peripheralmanager/example/pio_mcp9808.cc
new file mode 100644
index 0000000..446afbf
--- /dev/null
+++ b/peripheralmanager/example/pio_mcp9808.cc
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2015 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 <arpa/inet.h>
+#include <unistd.h>
+
+#include <memory>
+
+#include <base/logging.h>
+#include <brillo/flag_helper.h>
+
+#include <peripheralmanager/peripheral_manager_client.h>
+
+int main(int argc, char* argv[]) {
+ brillo::FlagHelper::Init(argc, argv, "PeripheralManager client.");
+ logging::InitLogging(logging::LoggingSettings());
+
+ // Get a client to the PeripheralManager.
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+
+ if (!client) {
+ LOG(ERROR) << "Failed to connect to client";
+ return 1;
+ }
+
+ // Open I2C bus.
+ BI2cDevice* i2c_device;
+ int ret =
+ BPeripheralManagerClient_openI2cDevice(client, "I2C6", 0x18, &i2c_device);
+ if (ret) {
+ LOG(ERROR) << "Failed to open I2C: " << strerror(ret);
+ return 1;
+ }
+
+ uint16_t val = 0;
+ BI2cDevice_readRegWord(i2c_device, 0x05, &val);
+
+ val = ntohs(val);
+ float temp = (val >> 4) & 0xFF;
+ temp += (float)(val & 0xF) / 16;
+ printf("Temp: %f\n", temp);
+
+ BI2cDevice_delete(i2c_device);
+
+ // Close the connection to PeripheralManager.
+ BPeripheralManagerClient_delete(client);
+
+ return 0;
+}
diff --git a/peripheralmanager/example/pio_uart.cc b/peripheralmanager/example/pio_uart.cc
new file mode 100644
index 0000000..628a746
--- /dev/null
+++ b/peripheralmanager/example/pio_uart.cc
@@ -0,0 +1,89 @@
+/*
+ * 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 <base/logging.h>
+#include <brillo/flag_helper.h>
+
+#include <peripheralmanager/peripheral_manager_client.h>
+
+int main(int argc, char* argv[]) {
+ brillo::FlagHelper::Init(argc, argv, "PeripheralManager client.");
+ logging::InitLogging(logging::LoggingSettings());
+
+ // Get a client to the PeripheralManager.
+ BPeripheralManagerClient* client = BPeripheralManagerClient_new();
+
+ if (!client) {
+ LOG(ERROR) << "Failed to connect to client";
+ return 1;
+ }
+
+ BUartDevice* uart;
+ int ret = BPeripheralManagerClient_openUartDevice(client, "UART1", &uart);
+ if (ret) {
+ LOG(ERROR) << "Failed to open UART device";
+ return 1;
+ }
+
+ ret = BUartDevice_setBaudrate(uart, 9600);
+
+ char greeting[] = "What is your name ?\n";
+ uint32_t written = 0;
+ ret = BUartDevice_write(uart, greeting, strlen(greeting), &written);
+ if (ret) {
+ LOG(ERROR) << "failed to write: " << strerror(ret);
+ return 1;
+ }
+
+ std::string name = "";
+
+ while (name.size() < 40) {
+ // If the user entered a newline, everything before is the name.
+ auto first_newline = name.find(13);
+ if (first_newline != std::string::npos) {
+ name.resize(first_newline);
+ break;
+ }
+
+ char buffer[40];
+ uint32_t bytes_read = 0;
+
+ // Read some data.
+ ret = BUartDevice_read(uart, buffer, 40, &bytes_read);
+ if (ret != 0 && ret != EAGAIN) {
+ LOG(ERROR) << "failed to read: " << strerror(ret);
+ return 1;
+ }
+ LOG(INFO) << "read " << bytes_read << "bytes";
+ name.append(buffer, bytes_read);
+
+ // Wait a little before reading again.
+ // This should be replaced by a more efficient polling mechanism when it is
+ // ready.
+ sleep(2);
+ }
+
+ LOG(INFO) << "hello " << name;
+
+ // Release the UART object.
+ BUartDevice_delete(uart);
+
+ // Close the connection to PeripheralManager.
+ BPeripheralManagerClient_delete(client);
+
+ LOG(INFO) << "Exiting";
+ return 0;
+}
diff --git a/peripheralmanager/hal/Android.mk b/peripheralmanager/hal/Android.mk
new file mode 100644
index 0000000..9e0d4e1
--- /dev/null
+++ b/peripheralmanager/hal/Android.mk
@@ -0,0 +1,22 @@
+#
+# 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.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := peripheral_manager_hal_headers
+LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)
+include $(BUILD_STATIC_LIBRARY)
diff --git a/peripheralmanager/hal/hardware/peripheral_io.h b/peripheralmanager/hal/hardware/peripheral_io.h
new file mode 100644
index 0000000..624e83b
--- /dev/null
+++ b/peripheralmanager/hal/hardware/peripheral_io.h
@@ -0,0 +1,286 @@
+/*
+ * 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.
+ */
+
+#ifndef ANDROID_PERIPHERAL_IO_INTERFACE_H
+#define ANDROID_PERIPHERAL_IO_INTERFACE_H
+
+#include <stdint.h>
+#include <sys/cdefs.h>
+#include <sys/types.h>
+
+#include <hardware/hardware.h>
+
+__BEGIN_DECLS
+
+/**
+ * Id of this module.
+ */
+#define PERIPHERAL_IO_HARDWARE_MODULE_ID "peripheral_io"
+
+/**
+ * Possible GPIO direction configuration.
+ */
+typedef enum {
+ GPIO_DIRECTION_IN, /** Input */
+ GPIO_DIRECTION_OUT_LOW, /** Output, initially low */
+ GPIO_DIRECTION_OUT_HIGH /** Output, initially high */
+} gpio_direction_t;
+
+/**
+ * Callback to enable a given pinmux source on a specific pin.
+ *
+ * Args:
+ * pin: Name of the pin.
+ * source: Name of the pinmux source to enable. When NULL, setup the pinmux
+ * to enable GPIO on this pin.
+ *
+ * Returns:
+ * 0 on success, errno on error.
+ */
+typedef int (*pin_mux_cb)(const char* pin, const char* source);
+
+/**
+ * Callback to set the direction of a given GPIO.
+ *
+ * Args:
+ * pin: Name of the pin to configure.
+ * dir: Direction to set. One of gpio_direction_t.
+ *
+ * Returns:
+ * 0 on success, errno on error.
+ */
+typedef int (*pin_mux_direction_cb)(const char* pin, int dir);
+
+/**
+ * Callbacks used by peripheral manager to configure given pins.
+ */
+typedef struct pin_mux_callbacks {
+ pin_mux_cb mux_cb;
+ pin_mux_direction_cb direction_cb;
+} pin_mux_callbacks;
+
+/**
+ * Callbacks into peripheral manager.
+ *
+ * Those callbacks must be used in register_devices to declare the available
+ * interfaces to peripheral manager.
+ *
+ * All peripherals are referred to by their friendly name.
+ * The friendly name is a string, used to refer to a given peripheral (ex: gpio
+ * name, spi bus name) that is simple to understand, well documented for the
+ * board and unambiguous.
+ *
+ * Before coming up with a new naming scheme, consider:
+ * - Using an existing naming scheme: if the board provides an arduino pinout, a
+ * raspberry Pi pinout or a 96 boards pinout, use it.
+ * - Using the names written on the board next to the physical ports if any.
+ * - Using the documented name when widely available.
+ * Referring to the same pin or peripheral by two different names in the
+ * documentation and in peripheral manager would be confusing to the user.
+ *
+ * If coming up with a new name, use only simple characters (ideally, A-Z, 0-9,
+ * -, _).
+ */
+typedef struct peripheral_registration_cb_t {
+ /**
+ * Register a pin.
+ *
+ * Args:
+ * name: Friendly name (see definition above) of the pin.
+ * callbacks: Callbacks used to set up pinmuxes.
+ *
+ * Returns:
+ * 0 on success, errno on error.
+ */
+ int (*register_pin)(const char* name, int gpio, pin_mux_callbacks callbacks);
+
+ /**
+ * Register a pin group.
+ *
+ * Args:
+ * name: Name of the group.
+ * pins: List of pin names that are part of the group.
+ * nr_pins: Size of |pins|.
+ *
+ * Returns:
+ * 0 on success, errno on error.
+ */
+ int (*register_pin_group)(const char* name, char** pins, size_t nr_pins);
+
+ /**
+ * Register a pinmux source.
+ *
+ * Args:
+ * name: Name of the pinmux source.
+ * groups: List of possible pinmux groups this source can come up on.
+ * nr_groups: Size of |groups|.
+ *
+ * Returns:
+ * 0 on success, errno on error.
+ */
+ int (*register_source)(const char* name, char** groups, size_t nr_groups);
+
+ /**
+ * Register a simple source, mapped to a single pin group.
+ *
+ * This convenience function replaces the two calls to register_pin_group and
+ * register_source in most cases.
+ *
+ * Args:
+ * name: Name of the pinmux source.
+ * pins: List of pins this source comes up on.
+ * nr_pins: Size of |pins|.
+ *
+ * Returns:
+ * 0 on success, errno on error.
+ */
+ int (*register_simple_source)(const char* name,
+ const char** pins,
+ size_t nr_pins);
+
+ /**
+ * Register a sysfs backed GPIO.
+ *
+ * Args:
+ * name: Friendly name of the GPIO.
+ * index: Index of the gpio in sysfs.
+ *
+ * Returns:
+ * 0 on success, errno on error.
+ */
+ int (*register_gpio_sysfs)(const char* name, uint32_t index);
+
+ /**
+ * Set the pinmux for a given GPIO.
+ *
+ * Args:
+ * name: Friendly name of the pin.
+ * source: Name of the pinmux source.
+ *
+ * Returns:
+ * 0 on success, errno on error.
+ */
+ int (*set_gpio_pin_mux)(const char* name, const char* source);
+
+ /**
+ * Register a SPI device.
+ *
+ * Args:
+ * name: Friendly name of the device.
+ * bus: Bus number.
+ * cs: Chip select.
+ *
+ * Returns:
+ * 0 on success, errno on error.
+ */
+ int (*register_spi_dev_bus)(const char* name, uint32_t bus, uint32_t cs);
+
+ /**
+ * Set the pinmux for a given SPI device.
+ *
+ * Args:
+ * name: Friendly name of the device.
+ * source: Name of the pinmuxing source.
+ *
+ * Returns:
+ * 0 on success, errno on error.
+ */
+ int (*set_spi_pin_mux)(const char* name, const char* source);
+
+ /**
+ * Register a sysfs-backed LED.
+ *
+ * Args:
+ * name: Friendly name of the LED.
+ * sysfs_name: Name of the device in sysfs.
+ *
+ * Returns:
+ * 0 on success, errno on error.
+ */
+ int (*register_led_sysfs)(const char* name, const char* sysfs_name);
+
+ /**
+ * Register a UART bus.
+ *
+ * Args:
+ * name: Friendly name of the bus.
+ * dev_name: Name of the device in sysfs.
+ *
+ * Returns:
+ * 0 on success, errno on error.
+ */
+ int (*register_uart_bus)(const char* name, const char* dev_name);
+
+ /**
+ * Set the pinmux for a given UART bus.
+ *
+ * Args:
+ * name: Friendly name of the UART bus.
+ * source: Name of the pinmuxing source.
+ *
+ * Returns:
+ * 0 on success, errno on error.
+ */
+ int (*set_uart_pin_mux)(const char* name, const char* source);
+
+ /**
+ * Register an I2C bus.
+ *
+ * Args:
+ * name: Friendly name of the I2C device.
+ * bus: I2C bus number.
+ *
+ * Returns:
+ * 0 on success, errno on error.
+ */
+ int (*register_i2c_dev_bus)(const char* name, uint32_t bus);
+
+ /**
+ * Set the pinmux for a given I2C bus.
+ *
+ * Args:
+ * name: Friendly name of the I2C bus.
+ * source: Name of the pinmuxing source.
+ *
+ * Returns:
+ * 0 on success, errno on error.
+ */
+ int (*set_i2c_pin_mux)(const char* name, const char* source);
+
+} peripheral_registration_cb_t;
+
+typedef struct peripheral_io_module_t peripheral_io_module_t;
+
+struct peripheral_io_module_t {
+ struct hw_module_t common;
+
+ /**
+ * Register all available devices with the peripheral manager.
+ *
+ * Arguments:
+ * dev: Pointer to the peripheral_io module.
+ * callbacks: Callbacks into peripheral manager to register devices.
+ *
+ * Returns:
+ * 0 on success, errno on error.
+ */
+ int (*register_devices)(const peripheral_io_module_t* dev,
+ const peripheral_registration_cb_t* callbacks);
+};
+
+__END_DECLS
+
+#endif // ANDROID_PERIPHERAL_IO_INTERFACE_H
diff --git a/peripheralmanager/include/peripheralmanager/gpio.h b/peripheralmanager/include/peripheralmanager/gpio.h
new file mode 100644
index 0000000..d55a0ae
--- /dev/null
+++ b/peripheralmanager/include/peripheralmanager/gpio.h
@@ -0,0 +1,109 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_GPIO_H_
+#define SYSTEM_PERIPHERALMANAGER_GPIO_H_
+
+#include <sys/cdefs.h>
+#include <sys/types.h>
+
+__BEGIN_DECLS
+
+/// @defgroup Gpio Gpio Interface
+/// @brief Functions to control gpio pins.
+///
+/// These functions can be used to control gpio.
+/// @{
+
+/// Edge trigger types.
+enum {
+ NONE_EDGE, /**< None */
+ RISING_EDGE, /**< Rising edge */
+ FALLING_EDGE, /**< Falling edge */
+ BOTH_EDGE /**< Both edges */
+};
+
+/// GPIO direction types.
+enum {
+ DIRECTION_IN, /**< Input mode */
+ DIRECTION_OUT_INITIALLY_HIGH, /**< Output mode, initially set to high */
+ DIRECTION_OUT_INITIALLY_LOW /**< Output mode, initially set to low */
+};
+
+/// Possible active types.
+enum {
+ ACTIVE_LOW, /**< Active Low */
+ ACTIVE_HIGH /**< Active High */
+};
+
+typedef struct BGpio BGpio;
+
+
+
+/// Sets the GPIO direction to output.
+/// @param gpio Pointer to the BGpio struct
+/// @param direction One of DIRECTION_IN,
+/// DIRECTION_OUT_INITIALLY_HIGH, DIRECTION_OUT_INITIALLY_LOW.
+/// @return 0 on success, errno on error.
+int BGpio_setDirection(const BGpio* gpio, int direction);
+
+/// Sets the interrupt edge trigger type.
+/// @param gpio Pointer to the BGpio struct
+/// @param type One of NONE_EDGE, RISING_EDGE, FALLING_EDGE or BOTH_EDGE.
+/// @return 0 on success, errno on error.
+int BGpio_setEdgeTriggerType(const BGpio* gpio, int type);
+
+/// Sets the GPIO’s active low/high status.
+/// @param gpio Pointer to the BGpio struct.
+/// @param type One of ACTIVE_HIGH, ACTIVE_LOW.
+/// @return 0 on success, errno on error.
+int BGpio_setActiveType(const BGpio* gpio, int type);
+
+/// Sets the GPIO value (for output GPIO only).
+/// @param gpio Pointer to the BGpio struct.
+/// @param value Value to set.
+/// @return 0 on success, errno on error.
+int BGpio_setValue(const BGpio* gpio, int value);
+
+/// Gets the GPIO value (for input GPIO only).
+/// @param gpio Pointer to the BGpio struct.
+/// @param value Output pointer to the value of the GPIO.
+/// @return 0 on success, errno on error.
+int BGpio_getValue(const BGpio* gpio, int* value);
+
+/// Returns a file descriptor that can be used to poll on new data.
+/// Can be passed to select/epoll to wait for data to become available.
+/// @param gpio Pointer to the BGpio struct.
+/// @param fd Output pointer to the file descriptor number.
+/// @return 0 on success, errno on error.
+int BGpio_getPollingFd(const BGpio* gpio, int* fd);
+
+/// Acknowledges the interrupt and resets the file descriptor.
+/// This must be called after each event triggers in order to be able to
+/// poll/select for another event.
+/// @param fd Polling file descriptor to reset.
+/// @return 0 on success, errno on error.
+int BGpio_ackInterruptEvent(int fd);
+
+/// Destroys a BGpio struct.
+/// @param gpio Pointer to the BGpio struct.
+void BGpio_delete(BGpio* gpio);
+
+/// @}
+
+__END_DECLS
+
+#endif // SYSTEM_PERIPHERALMANAGER_GPIO_H_
diff --git a/peripheralmanager/include/peripheralmanager/i2c_device.h b/peripheralmanager/include/peripheralmanager/i2c_device.h
new file mode 100644
index 0000000..ca14477
--- /dev/null
+++ b/peripheralmanager/include/peripheralmanager/i2c_device.h
@@ -0,0 +1,121 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_I2C_DEVICE_H_
+#define SYSTEM_PERIPHERALMANAGER_I2C_DEVICE_H_
+
+#include <sys/cdefs.h>
+#include <sys/types.h>
+
+__BEGIN_DECLS
+
+/// @defgroup I2c I2c device interface
+/// @brief Functions to control an I2C device.
+///
+/// These functions can be used to control an I2C device.
+/// @{
+
+typedef struct BI2cDevice BI2cDevice;
+
+/// Reads from the device.
+/// @param device Pointer to the BI2cDevice struct.
+/// @param data Output buffer to write the data to.
+/// @param len Number of bytes to read.
+/// @param bytes_read Output pointer to the number of bytes actually read.
+/// @return 0 on success, errno on error
+int BI2cDevice_read(const BI2cDevice* device,
+ void* data,
+ uint32_t len,
+ uint32_t* bytes_read);
+
+/// Reads a byte from an I2C register.
+/// @param device Pointer to the BI2cDevice struct.
+/// @param reg Register to read from.
+/// @param val Output pointer to value to read.
+/// @return 0 on success, errno on error
+int BI2cDevice_readRegByte(const BI2cDevice* device, uint8_t reg, uint8_t* val);
+
+/// Reads a word from an I2C register.
+/// @param device Pointer to the BI2cDevice struct.
+/// @param reg Register to read from.
+/// @param val Output pointer to value to read.
+/// @return 0 on success, errno on error
+int BI2cDevice_readRegWord(const BI2cDevice* device,
+ uint8_t reg,
+ uint16_t* val);
+
+/// Reads from an I2C register.
+/// @param device Pointer to the BI2cDevice struct.
+/// @param reg Register to read from.
+/// @param data Output buffer to write the data to.
+/// @param len Number of bytes to read.
+/// @param bytes_read Output pointer to the number of bytes read.
+/// @return 0 on success, errno on error
+int BI2cDevice_readRegBuffer(const BI2cDevice* device,
+ uint8_t reg,
+ void* data,
+ uint32_t len,
+ uint32_t* bytes_read);
+
+/// Writes to the device.
+/// @param device Pointer to the BI2cDevice struct.
+/// @param data Buffer to write.
+/// @param len Number of bytes to write.
+/// @param bytes_written Output pointer to the number of bytes written.
+/// @return 0 on success, errno on error
+int BI2cDevice_write(const BI2cDevice* device,
+ const void* data,
+ uint32_t len,
+ uint32_t* bytes_written);
+
+/// Writes a byte to an I2C register.
+/// @param device Pointer to the BI2cDevice struct.
+/// @param reg Register to write to.
+/// @param val Value to write.
+/// @return 0 on success, errno on error
+int BI2cDevice_writeRegByte(const BI2cDevice* device, uint8_t reg, uint8_t val);
+
+/// Writes a word to an I2C register.
+/// @param device Pointer to the BI2cDevice struct.
+/// @param reg Register to write to.
+/// @param val Value to write.
+/// @return 0 on success, errno on error
+int BI2cDevice_writeRegWord(const BI2cDevice* device,
+ uint8_t reg,
+ uint16_t val);
+
+/// Writes to an I2C register.
+/// @param device Pointer to the BI2cDevice struct.
+/// @param reg Register to write to.
+/// @param data Data to write.
+/// @param len Number of bytes to write.
+/// @param bytes_written Output pointer to the number of bytes written.
+/// @return 0 on success, errno on error
+int BI2cDevice_writeRegBuffer(const BI2cDevice* device,
+ uint8_t reg,
+ const void* data,
+ uint32_t len,
+ uint32_t* bytes_written);
+
+/// Destroys a BI2cDevice struct.
+/// @param device Pointer to the BI2cDevice struct.
+void BI2cDevice_delete(BI2cDevice* device);
+
+/// @}
+
+__END_DECLS
+
+#endif // SYSTEM_PERIPHERALMANAGER_I2C_DEVICE_H_
diff --git a/peripheralmanager/include/peripheralmanager/led.h b/peripheralmanager/include/peripheralmanager/led.h
new file mode 100644
index 0000000..c8cc19b
--- /dev/null
+++ b/peripheralmanager/include/peripheralmanager/led.h
@@ -0,0 +1,60 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_LED_H_
+#define SYSTEM_PERIPHERALMANAGER_LED_H_
+
+#include <sys/cdefs.h>
+#include <sys/types.h>
+
+__BEGIN_DECLS
+
+/// @defgroup Led Led Interface
+/// @brief Functions to control onboard LEDs.
+///
+/// These functions can be used to query and control LEDs.
+/// @{
+
+typedef struct BLed BLed;
+
+/// Sets the LED brightness.
+/// @param led Pointer to the BLed object.
+/// @param brightness Brightness to set. If the brightness exceeds the maximum
+/// brightness supported, sets the maximum supported.
+/// @return 0 on success, errno on error.
+int BLed_setBrightness(const BLed* led, uint32_t brightness);
+
+/// Gets the LED brightness.
+/// @param led Pointer to the BLed object.
+/// @param brightness Output pointer to the current brightness.
+/// @return 0 on success, errno on error.
+int BLed_getBrightness(const BLed* led, uint32_t* brightness);
+
+/// Gets the LED max brightness.
+/// @param led Pointer to the BLed object.
+/// @param max_brightness Output pointer to the maximum brightness supported.
+/// @return 0 on success, errno on error.
+int BLed_getMaxBrightness(const BLed* led, uint32_t* max_brightness);
+
+/// Destroys a BLed object.
+/// @param led Pointer to the BLed object to destroy.
+void BLed_delete(BLed* led);
+
+/// @}
+
+__END_DECLS
+
+#endif // SYSTEM_PERIPHERALMANAGER_LED_H_
diff --git a/peripheralmanager/include/peripheralmanager/peripheral_manager_client.h b/peripheralmanager/include/peripheralmanager/peripheral_manager_client.h
new file mode 100644
index 0000000..51821b0
--- /dev/null
+++ b/peripheralmanager/include/peripheralmanager/peripheral_manager_client.h
@@ -0,0 +1,143 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_PERIPHERAL_MANAGER_CLIENT_H_
+#define SYSTEM_PERIPHERALMANAGER_PERIPHERAL_MANAGER_CLIENT_H_
+
+#include <sys/cdefs.h>
+
+#include "peripheralmanager/gpio.h"
+#include "peripheralmanager/i2c_device.h"
+#include "peripheralmanager/led.h"
+#include "peripheralmanager/spi_device.h"
+#include "peripheralmanager/uart_device.h"
+
+__BEGIN_DECLS
+
+/// @defgroup PeripheralManagerClient Peripheral client functions
+/// @brief Functions to access embedded peripherals
+/// @{
+
+typedef struct BPeripheralManagerClient BPeripheralManagerClient;
+
+/// Returns the list of GPIOs.
+/// This does not take ownership into account.
+/// The list must be freed by the caller.
+/// @param client Pointer to the BPeripheralManagerClient struct.
+/// @param num_gpio Output pointer to the number of element in the list.
+/// @return The list of gpios.
+char** BPeripheralManagerClient_listGpio(const BPeripheralManagerClient* client,
+ int* num_gpio);
+
+/// Opens a GPIO and takes ownership of it.
+/// @param client Pointer to the BPeripheralManagerClient struct.
+/// @param name Name of the GPIO.
+/// @param gpio Output pointer to the BGpio struct. Empty on error.
+/// @return 0 on success, errno on error.
+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 0 on success, errno on error.
+int BPeripheralManagerClient_openSpiDevice(
+ const BPeripheralManagerClient* client,
+ const char* name,
+ BSpiDevice** dev);
+
+/// Returns the list of LEDs available.
+/// @param client Pointer to the BPeripheralManagerClient struct.
+/// @param num_leds Output pointer to the number of leds.
+/// @return The list of LEDs. The list must be freed by the caller.
+char** BPeripheralManagerClient_listLeds(const BPeripheralManagerClient* client,
+ int* num_leds);
+
+/// Opens an LED and takes ownership of it.
+/// @oaram client Pointer to the BPeripheralManagerClient struct.
+/// @param name Name of the LED.
+/// @param dev Output pointer to the BLed struct. Empty on error.
+/// @return 0 on success, errno on error.
+int BPeripheralManagerClient_openLed(const BPeripheralManagerClient* client,
+ const char* name,
+ BLed** led);
+
+/// Returns the list of I2C 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_i2c_buses Output pointer to the number of element in the list.
+/// @return The list of i2c buses.
+char** BPeripheralManagerClient_listI2cBuses(
+ const BPeripheralManagerClient* client,
+ int* num_i2c_buses);
+
+/// Opens an I2C device and takes ownership of it.
+/// @param client Pointer to the BPeripheralManagerClient struct.
+/// @param name Name of the I2C bus.
+/// @param address Address of the I2C device.
+/// @param dev Output pointer to the BI2cDevice struct. Empty on error.
+/// @return 0 on success, errno on error
+int BPeripheralManagerClient_openI2cDevice(
+ const BPeripheralManagerClient* client,
+ const char* name,
+ uint32_t address,
+ BI2cDevice** dev);
+
+/// Returns the list of UART 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_uart_buses Output pointer to the number of element in the list.
+/// @return The list of uart buses.
+char** BPeripheralManagerClient_listUartDevices(
+ const BPeripheralManagerClient* client, int* num_uart_buses);
+
+/// Opens an UART device and takes ownership of it.
+/// @param client Pointer to the BPeripheralManagerClient struct.
+/// @param name Name of the UART device.
+/// @param dev Output pointer to the BUartDevice struct. Empty on error.
+/// @return 0 on success, errno on error
+int BPeripheralManagerClient_openUartDevice(
+ const BPeripheralManagerClient* client,
+ const char* name,
+ BUartDevice** dev);
+
+/// Creates a new client.
+/// @return A pointer to the created client. nullptr on errors.
+BPeripheralManagerClient* BPeripheralManagerClient_new();
+
+/// Destroys the peripheral manager client.
+/// @param client Pointer to the BPeripheralManagerClient struct.
+void BPeripheralManagerClient_delete(BPeripheralManagerClient* client);
+
+/// @}
+
+__END_DECLS
+
+#endif // SYSTEM_PERIPHERALMANAGER_PERIPHERAL_MANAGER_CLIENT_H_
diff --git a/peripheralmanager/include/peripheralmanager/spi_device.h b/peripheralmanager/include/peripheralmanager/spi_device.h
new file mode 100644
index 0000000..e81bdc1
--- /dev/null
+++ b/peripheralmanager/include/peripheralmanager/spi_device.h
@@ -0,0 +1,118 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_SPI_DEVICE_H_
+#define SYSTEM_PERIPHERALMANAGER_SPI_DEVICE_H_
+
+#include <sys/cdefs.h>
+#include <sys/types.h>
+
+__BEGIN_DECLS
+
+/// @defgroup Spi Spi device interface
+/// @brief Functions to control an SPI device.
+///
+/// These functions can be used to control an SPI device.
+/// @{
+
+/// Endianness.
+enum {
+ SPI_LSB_FIRST, /**< Least significant bits first */
+ SPI_MSB_FIRST /**< Most significant bits first */
+};
+
+/// SPI phase modes.
+enum {
+ SPI_CPHA = 0x01, /**< Clock phase */
+ SPI_CPOL = 0x02 /**< Clock polarity */
+};
+
+/// SPI modes (similar to the Linux kernel's modes).
+enum {
+ SPI_MODE0 = 0, /**< CPHA=0, CPOL=0 */
+ SPI_MODE1 = SPI_CPHA, /**< CPHA=1, CPOL=0 */
+ SPI_MODE2 = SPI_CPOL, /**< CPHA=0, CPOL=1 */
+ SPI_MODE3 = SPI_CPHA + SPI_CPOL /**< CPHA=1, CPOL=1 */
+};
+
+typedef struct BSpiDevice BSpiDevice;
+
+/// Writes a byte to the device.
+/// @param device Pointer to the BSpiDevice struct.
+/// @param val Value to write.
+/// @return 0 on success, errno on error.
+int BSpiDevice_writeByte(const BSpiDevice* device, uint8_t val);
+
+/// Writes a buffer to the device.
+/// @param device Pointer to the BSpiDevice struct.
+/// @param data Buffer to write.
+/// @param len Length of the buffer.
+/// @return 0 on success, errno on error.
+int BSpiDevice_writeBuffer(const BSpiDevice* device,
+ const void* data,
+ size_t len);
+
+/// Transfer data to the device.
+/// @param device Pointer to the BSpiDevice struct.
+/// @param tx_data Buffer to write.
+/// @param rx_data Buffer to read data in. If NULL, no data will be read.
+/// @param len Length of the buffers.
+/// @return 0 on success, errno on error.
+int BSpiDevice_transfer(const BSpiDevice* device,
+ const void* tx_data,
+ void* rx_data,
+ size_t len);
+
+/// Sets the frequency in Hertz.
+/// @param device Pointer to the BSpiDevice struct.
+/// @param freq_hz Frequency to set.
+/// @return 0 on success, errno on error.
+int BSpiDevice_setFrequency(const BSpiDevice* device, uint32_t freq_hz);
+
+/// Sets the SPI mode.
+/// @param device Pointer to the BSpiDevice struct.
+/// @param mode Mode to use. One of SPI_MODE0, SPI_MODE1, SPI_MODE2, SPI_MODE3.
+/// @return 0 on success, errno on error.
+int BSpiDevice_setMode(const BSpiDevice* device, int mode);
+
+/// Sets the bit justification.
+/// @param device Pointer to the BSpiDevice struct.
+/// @param bit_justification One of SPI_LSB_FIRST OR SPI_MSB_FIRST.
+/// @return 0 on success, errno on error.
+int BSpiDevice_setBitJustification(const BSpiDevice* device,
+ int bit_justification);
+
+/// Sets the number of bits per words.
+/// @param device Pointer to the BSpiDevice struct.
+/// @param bits_per_word Number of bits per word.
+/// @return 0 on success, errno on error.
+int BSpiDevice_setBitsPerWord(const BSpiDevice* device, uint8_t bits_per_word);
+
+/// Sets the delay to wait after each transfer.
+/// @param device Pointer to the BSpiDevice struct.
+/// @param delay_usecs Delay in microseconds.
+/// @return 0 on success, errno on error.
+int BSpiDevice_setDelay(const BSpiDevice* device, uint16_t delay_usecs);
+
+/// Destroys a BSpiDevice struct.
+/// @param device Pointer to the BSpiDevice struct.
+void BSpiDevice_delete(BSpiDevice* device);
+
+/// @}
+
+__END_DECLS
+
+#endif // SYSTEM_PERIPHERALMANAGER_SPI_DEVICE_H_
diff --git a/peripheralmanager/include/peripheralmanager/uart_device.h b/peripheralmanager/include/peripheralmanager/uart_device.h
new file mode 100644
index 0000000..057a068
--- /dev/null
+++ b/peripheralmanager/include/peripheralmanager/uart_device.h
@@ -0,0 +1,70 @@
+/*
+ * 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.
+ */
+
+#ifndef SYSTEM_PERIPHERALMANAGER_UART_DEVICE_H_
+#define SYSTEM_PERIPHERALMANAGER_UART_DEVICE_H_
+
+#include <sys/cdefs.h>
+#include <sys/types.h>
+
+__BEGIN_DECLS
+
+/// @defgroup Uart Uart device interface
+/// @brief Functions to control an UART device.
+///
+/// These functions can be used to control an UART device.
+/// @{
+
+typedef struct BUartDevice BUartDevice;
+
+/// Writes to a UART device.
+/// @param device Pointer to the BUartDevice struct.
+/// @param data Data to write.
+/// @param len Size of the data to write.
+/// @param bytes_written Output pointer to the number of bytes written.
+/// @return 0 on success, errno on error.
+int BUartDevice_write(const BUartDevice* device,
+ const void* data,
+ uint32_t len,
+ uint32_t* bytes_written);
+
+/// Reads from a UART device.
+/// @param device Pointer to the BUartDevice struct.
+/// @param data Buffer to read the data into.
+/// @param len Number of bytes to read.
+/// @param bytes_read Output pointer to the number of bytes read.
+/// @return 0 on success, errno on error.
+int BUartDevice_read(const BUartDevice* device,
+ void* data,
+ uint32_t len,
+ uint32_t* bytes_read);
+
+/// Sets the input and output speed of a UART device.
+/// @param device Pointer to the BUartDevice struct.
+/// @param device Uart device to configure.
+/// @param baudrate Speed in baud.
+/// @return 0 on success, errno on error.
+int BUartDevice_setBaudrate(const BUartDevice* device, uint32_t baudrate);
+
+/// Destroys a BUartDevice struct.
+/// @param device Pointer to the BUartDevice struct.
+void BUartDevice_delete(BUartDevice* device);
+
+/// @}
+
+__END_DECLS
+
+#endif // SYSTEM_PERIPHERALMANAGER_UART_DEVICE_H_
diff --git a/peripheralmanager/ipc/Android.mk b/peripheralmanager/ipc/Android.mk
new file mode 100644
index 0000000..1d132fe
--- /dev/null
+++ b/peripheralmanager/ipc/Android.mk
@@ -0,0 +1,33 @@
+#
+# Copyright (C) 2015 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.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := libperipheralman_binder
+
+LOCAL_SHARED_LIBRARIES := libbinder
+LOCAL_EXPORT_SHARED_LIBRARY_HEADERS := libbinder
+
+LOCAL_SRC_FILES := \
+ android/os/IPeripheralManagerClient.aidl \
+ android/os/IPeripheralManager.aidl \
+
+LOCAL_SHARED_LIBRARIES := libbinder
+
+LOCAL_AIDL_INCLUDES := $(LOCAL_PATH)
+
+include $(BUILD_STATIC_LIBRARY)
diff --git a/peripheralmanager/ipc/android/os/IPeripheralManager.aidl b/peripheralmanager/ipc/android/os/IPeripheralManager.aidl
new file mode 100644
index 0000000..39f4c9b
--- /dev/null
+++ b/peripheralmanager/ipc/android/os/IPeripheralManager.aidl
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+
+package android.os;
+
+import android.os.IPeripheralManagerClient;
+
+interface IPeripheralManager {
+ IPeripheralManagerClient GetClient(IBinder lifeline);
+}
diff --git a/peripheralmanager/ipc/android/os/IPeripheralManagerClient.aidl b/peripheralmanager/ipc/android/os/IPeripheralManagerClient.aidl
new file mode 100644
index 0000000..98e1196
--- /dev/null
+++ b/peripheralmanager/ipc/android/os/IPeripheralManagerClient.aidl
@@ -0,0 +1,117 @@
+/*
+ * 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.
+ */
+
+package android.os;
+
+interface IPeripheralManagerClient {
+ // Gpio functions.
+ void ListGpio(out @utf8InCpp List<String> gpios);
+
+ void OpenGpio(@utf8InCpp String name);
+
+ void ReleaseGpio(@utf8InCpp String name);
+
+ void SetGpioEdge(@utf8InCpp String name, int type);
+
+ void SetGpioActiveType(@utf8InCpp String name, int type);
+
+ void SetGpioDirection(@utf8InCpp String name, int direction);
+
+ void SetGpioValue(@utf8InCpp String name, boolean value);
+
+ boolean GetGpioValue(@utf8InCpp String name);
+
+ FileDescriptor GetGpioPollingFd(@utf8InCpp String name);
+
+
+ // Spi functions.
+ void ListSpiBuses(out @utf8InCpp List<String> buses);
+
+ void OpenSpiDevice(@utf8InCpp String name);
+
+ void ReleaseSpiDevice(@utf8InCpp String name);
+
+ void SpiDeviceWriteByte(@utf8InCpp String name, byte data);
+
+ void SpiDeviceWriteBuffer(@utf8InCpp String name, in byte[] buffer);
+
+ void SpiDeviceTransfer(@utf8InCpp String name, in @nullable byte[] tx_data,
+ out @nullable byte[] rx_data, int len);
+
+ void SpiDeviceSetFrequency(@utf8InCpp String name, int frequency_hz);
+
+ void SpiDeviceSetBitJustification(@utf8InCpp String name,
+ boolean lsb_first);
+
+ void SpiDeviceSetMode(@utf8InCpp String name, int mode);
+
+ void SpiDeviceSetBitsPerWord(@utf8InCpp String name, int nbits);
+
+ void SpiDeviceSetDelay(@utf8InCpp String name, int delay_usecs);
+
+
+ // Leds functions.
+ void ListLeds(out @utf8InCpp List<String> leds);
+
+ void OpenLed(@utf8InCpp String name);
+
+ void ReleaseLed(@utf8InCpp String name);
+
+ int LedGetBrightness(@utf8InCpp String name);
+
+ int LedGetMaxBrightness(@utf8InCpp String name);
+
+ void LedSetBrightness(@utf8InCpp String name, int brightness);
+
+
+ // I2c functions.
+ void ListI2cBuses(out @utf8InCpp List<String> buses);
+
+ void OpenI2cDevice(@utf8InCpp String name, int address);
+
+ void ReleaseI2cDevice(@utf8InCpp String name, int address);
+
+ int I2cRead(@utf8InCpp String name, int address, out byte[] data, int size);
+
+ int I2cReadRegByte(@utf8InCpp String name, int address, int reg);
+
+ int I2cReadRegWord(@utf8InCpp String name, int address, int reg);
+
+ int I2cReadRegBuffer(@utf8InCpp String name, int address, int reg,
+ out byte[] data, int size);
+
+ int I2cWrite(@utf8InCpp String name, int address, in byte[] data);
+
+ void I2cWriteRegByte(@utf8InCpp String name, int address, int reg, byte val);
+
+ void I2cWriteRegWord(@utf8InCpp String name, int address, int reg, int val);
+
+ 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);
+}
