From 9550981cc0ca309b6a7257e8b4bc84d3733d0c45 Mon Sep 17 00:00:00 2001 From: Badhri Jagan Sridharan Date: Mon, 13 Mar 2017 15:12:36 -0700 Subject: [PATCH] exynos9610: USB HAL: initial type-c hal Bug: 36097487 Test: Manually tested role swap and UI behavior Change-Id: I5ce520da521e0714001b60164ac850dddbd644c3 --- hidl/usb/Android.mk | 36 ++ hidl/usb/Usb.cpp | 496 ++++++++++++++++++ hidl/usb/Usb.h | 52 ++ ...android.hardware.usb@1.0-service.device.rc | 10 + hidl/usb/service.cpp | 40 ++ 5 files changed, 634 insertions(+) create mode 100644 hidl/usb/Android.mk create mode 100644 hidl/usb/Usb.cpp create mode 100644 hidl/usb/Usb.h create mode 100644 hidl/usb/android.hardware.usb@1.0-service.device.rc create mode 100644 hidl/usb/service.cpp diff --git a/hidl/usb/Android.mk b/hidl/usb/Android.mk new file mode 100644 index 0000000..3aaa8e9 --- /dev/null +++ b/hidl/usb/Android.mk @@ -0,0 +1,36 @@ +# Copyright (C) 2017 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_RELATIVE_PATH := hw +LOCAL_PROPRIETARY_MODULE := true +LOCAL_MODULE := android.hardware.usb@1.0-service.device +LOCAL_INIT_RC := android.hardware.usb@1.0-service.device.rc +LOCAL_SRC_FILES := \ + service.cpp \ + Usb.cpp + +LOCAL_SHARED_LIBRARIES := \ + libcutils \ + libhidlbase \ + libhidltransport \ + liblog \ + libhwbinder \ + libutils \ + libhardware \ + android.hardware.usb@1.0 \ + +include $(BUILD_EXECUTABLE) diff --git a/hidl/usb/Usb.cpp b/hidl/usb/Usb.cpp new file mode 100644 index 0000000..0a9529c --- /dev/null +++ b/hidl/usb/Usb.cpp @@ -0,0 +1,496 @@ +/* + * Copyright (C) 2017 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 +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "Usb.h" + +namespace android { +namespace hardware { +namespace usb { +namespace V1_0 { +namespace implementation { + +// Set by the signal handler to destroy the thread +volatile bool destroyThread; + +int32_t readFile(std::string filename, std::string *contents) { + FILE *fp; + ssize_t read = 0; + char *line = NULL; + size_t len = 0; + + fp = fopen(filename.c_str(), "r"); + if (fp != NULL) { + if ((read = getline(&line, &len, fp)) != -1) { + char *pos; + if ((pos = strchr(line, '\n')) != NULL) *pos = '\0'; + *contents = line; + } + free(line); + fclose(fp); + return 0; + } else { + ALOGE("fopen failed"); + } + + return -1; +} + +std::string appendRoleNodeHelper(const std::string portName, + PortRoleType type) { + std::string node("/sys/class/typec/" + portName); + + switch (type) { + case PortRoleType::DATA_ROLE: + return node + "/current_data_role"; + case PortRoleType::POWER_ROLE: + return node + "/current_power_role"; + default: + return node + "/mode"; + } +} + +std::string convertRoletoString(PortRole role) { + if (role.type == PortRoleType::POWER_ROLE) { + if (role.role == static_cast(PortPowerRole::SOURCE)) + return "source"; + else if (role.role == static_cast(PortPowerRole::SINK)) + return "sink"; + } else if (role.type == PortRoleType::DATA_ROLE) { + if (role.role == static_cast(PortDataRole::HOST)) return "host"; + if (role.role == static_cast(PortDataRole::DEVICE)) + return "device"; + } else if (role.type == PortRoleType::MODE) { + if (role.role == static_cast(PortMode::UFP)) return "ufp"; + if (role.role == static_cast(PortMode::DFP)) return "dfp"; + } + return "none"; +} + +void extractRole(std::string *roleName) { + std::size_t first, last; + + first = roleName->find("["); + last = roleName->find("]"); + + if (first != std::string::npos && last != std::string::npos) { + *roleName = roleName->substr(first + 1, last - first - 1); + } +} + +Return Usb::switchRole(const hidl_string &portName, + const PortRole &newRole) { + std::string filename = + appendRoleNodeHelper(std::string(portName.c_str()), newRole.type); + std::string written; + FILE *fp; + + ALOGI("filename write: %s role:%s", filename.c_str(), + convertRoletoString(newRole).c_str()); + + fp = fopen(filename.c_str(), "w"); + if (fp != NULL) { + int ret = fputs(convertRoletoString(newRole).c_str(), fp); + fclose(fp); + if ((ret != EOF) && !readFile(filename, &written)) { + extractRole(&written); + ALOGI("written: %s", written.c_str()); + if (written == convertRoletoString(newRole)) { + pthread_mutex_lock(&mLock); + if (mCallback != NULL) { + Return ret = mCallback->notifyRoleSwitchStatus( + portName, newRole, Status::SUCCESS); + if (!ret.isOk()) + ALOGE("RoleSwitch transaction error %s", ret.description().c_str()); + } else { + ALOGE("Not notifying the userspace. Callback is not set"); + } + pthread_mutex_unlock(&mLock); + return Void(); + } else { + ALOGE("Role switch failed"); + } + } else { + ALOGE("failed to update the new role"); + } + } else { + ALOGE("fopen failed"); + } + + pthread_mutex_lock(&mLock); + if (mCallback != NULL) { + Return ret = + mCallback->notifyRoleSwitchStatus(portName, newRole, Status::ERROR); + if (!ret.isOk()) + ALOGE("RoleSwitchStatus error %s", ret.description().c_str()); + } else { + ALOGE("Not notifying the userspace. Callback is not set"); + } + pthread_mutex_unlock(&mLock); + + return Void(); +} + +Status getCurrentRoleHelper(std::string portName, bool connected, + PortRoleType type, uint32_t *currentRole) { + std::string filename; + std::string roleName; + + // Mode + + if (type == PortRoleType::POWER_ROLE) { + filename = "/sys/class/typec/" + portName + "/current_power_role"; + *currentRole = static_cast(PortPowerRole::NONE); + } else if (type == PortRoleType::DATA_ROLE) { + filename = "/sys/class/typec/" + portName + "/current_data_role"; + *currentRole = static_cast(PortDataRole::NONE); + } else if (type == PortRoleType::MODE) { + filename = "/sys/class/typec/" + portName + "/current_data_role"; + *currentRole = static_cast(PortMode::NONE); + } else { + return Status::ERROR; + } + + if (!connected) return Status::SUCCESS; + + if (readFile(filename, &roleName)) { + ALOGE("getCurrentRole: Failed to open filesystem node: %s", + filename.c_str()); + return Status::ERROR; + } + + extractRole(&roleName); + + if (roleName == "source") { + *currentRole = static_cast(PortPowerRole::SOURCE); + } else if (roleName == "sink") { + *currentRole = static_cast(PortPowerRole::SINK); + } else if (roleName == "host") { + if (type == PortRoleType::DATA_ROLE) + *currentRole = static_cast(PortDataRole::HOST); + else + *currentRole = static_cast(PortMode::DFP); + } else if (roleName == "device") { + if (type == PortRoleType::DATA_ROLE) + *currentRole = static_cast(PortDataRole::DEVICE); + else + *currentRole = static_cast(PortMode::UFP); + } else if (roleName != "none") { + /* case for none has already been addressed. + * so we check if the role isnt none. + */ + return Status::UNRECOGNIZED_ROLE; + } + + return Status::SUCCESS; +} + +Status getTypeCPortNamesHelper(std::unordered_map *names) { + DIR *dp; + + dp = opendir("/sys/class/typec"); + if (dp != NULL) { + int32_t ports = 0; + int32_t current = 0; + struct dirent *ep; + + while ((ep = readdir(dp))) { + if (ep->d_type == DT_LNK) { + if (std::string::npos == std::string(ep->d_name).find("-partner")) { + std::unordered_map::const_iterator portName = + names->find(ep->d_name); + if (portName == names->end()) { + names->insert({ep->d_name, false}); + } + } else { + (*names)[std::strtok(ep->d_name, "-")] = true; + } + } + } + closedir(dp); + return Status::SUCCESS; + } + + ALOGE("Failed to open /sys/class/typec"); + return Status::ERROR; +} + +bool canSwitchRoleHelper(const std::string portName, PortRoleType /*type*/) { + std::string filename = + "/sys/class/typec/" + portName + "-partner/supports_usb_power_delivery"; + std::string supportsPD; + + if (!readFile(filename, &supportsPD)) { + if (supportsPD == "1") { + return true; + } + } + + return false; +} + +Status getPortStatusHelper(hidl_vec *currentPortStatus) { + std::unordered_map names; + Status result = getTypeCPortNamesHelper(&names); + int i = -1; + + if (result == Status::SUCCESS) { + currentPortStatus->resize(names.size()); + for (std::pair port : names) { + i++; + ALOGI("%s", port.first.c_str()); + (*currentPortStatus)[i].portName = port.first; + + uint32_t currentRole; + if (getCurrentRoleHelper(port.first, port.second, + PortRoleType::POWER_ROLE, + ¤tRole) == Status::SUCCESS) { + (*currentPortStatus)[i].currentPowerRole = + static_cast(currentRole); + } else { + ALOGE("Error while retreiving portNames"); + goto done; + } + + if (getCurrentRoleHelper(port.first, port.second, PortRoleType::DATA_ROLE, + ¤tRole) == Status::SUCCESS) { + (*currentPortStatus)[i].currentDataRole = + static_cast(currentRole); + } else { + ALOGE("Error while retreiving current port role"); + goto done; + } + + if (getCurrentRoleHelper(port.first, port.second, PortRoleType::MODE, + ¤tRole) == Status::SUCCESS) { + (*currentPortStatus)[i].currentMode = + static_cast(currentRole); + } else { + ALOGE("Error while retreiving current data role"); + goto done; + } + + (*currentPortStatus)[i].canChangeMode = false; + (*currentPortStatus)[i].canChangeDataRole = + port.second ? canSwitchRoleHelper(port.first, PortRoleType::DATA_ROLE) + : false; + (*currentPortStatus)[i].canChangePowerRole = + port.second + ? canSwitchRoleHelper(port.first, PortRoleType::POWER_ROLE) + : false; + + ALOGI("connected:%d canChangeMode: %d canChagedata: %d canChangePower:%d", + port.second, (*currentPortStatus)[i].canChangeMode, + (*currentPortStatus)[i].canChangeDataRole, + (*currentPortStatus)[i].canChangePowerRole); + + (*currentPortStatus)[i].supportedModes = PortMode::DRP; + } + return Status::SUCCESS; + } +done: + return Status::ERROR; +} + +Return Usb::queryPortStatus() { + hidl_vec currentPortStatus; + Status status; + + status = getPortStatusHelper(¤tPortStatus); + + pthread_mutex_lock(&mLock); + if (mCallback != NULL) { + Return ret = + mCallback->notifyPortStatusChange(currentPortStatus, status); + if (!ret.isOk()) + ALOGE("queryPortStatus error %s", ret.description().c_str()); + } else { + ALOGI("Notifying userspace skipped. Callback is NULL"); + } + pthread_mutex_unlock(&mLock); + + return Void(); +} +struct data { + int uevent_fd; + android::hardware::usb::V1_0::implementation::Usb *usb; +}; + +static void uevent_event(uint32_t /*epevents*/, struct data *payload) { + char msg[UEVENT_MSG_LEN + 2]; + char *cp; + int n; + + n = uevent_kernel_multicast_recv(payload->uevent_fd, msg, UEVENT_MSG_LEN); + if (n <= 0) return; + if (n >= UEVENT_MSG_LEN) /* overflow -- discard */ + return; + + msg[n] = '\0'; + msg[n + 1] = '\0'; + cp = msg; + + while (*cp) { + if (!strncmp(cp, "DEVTYPE=typec_", strlen("DEVTYPE=typec_"))) { + ALOGI("uevent received %s", cp); + pthread_mutex_lock(&payload->usb->mLock); + if (payload->usb->mCallback != NULL) { + hidl_vec currentPortStatus; + Status status = getPortStatusHelper(¤tPortStatus); + Return ret = payload->usb->mCallback->notifyPortStatusChange( + currentPortStatus, status); + if (!ret.isOk()) ALOGE("error %s", ret.description().c_str()); + } else { + ALOGI("Notifying userspace skipped. Callback is NULL"); + } + pthread_mutex_unlock(&payload->usb->mLock); + break; + } + /* advance to after the next \0 */ + while (*cp++) {} + } +} + +void *work(void *param) { + int epoll_fd, uevent_fd; + struct epoll_event ev; + int nevents = 0; + struct data payload; + + ALOGE("creating thread"); + + uevent_fd = uevent_open_socket(64 * 1024, true); + + if (uevent_fd < 0) { + ALOGE("uevent_init: uevent_open_socket failed\n"); + return NULL; + } + + payload.uevent_fd = uevent_fd; + payload.usb = (android::hardware::usb::V1_0::implementation::Usb *)param; + + fcntl(uevent_fd, F_SETFL, O_NONBLOCK); + + ev.events = EPOLLIN; + ev.data.ptr = (void *)uevent_event; + + epoll_fd = epoll_create(64); + if (epoll_fd == -1) { + ALOGE("epoll_create failed; errno=%d", errno); + goto error; + } + + if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, uevent_fd, &ev) == -1) { + ALOGE("epoll_ctl failed; errno=%d", errno); + goto error; + } + + while (!destroyThread) { + struct epoll_event events[64]; + + nevents = epoll_wait(epoll_fd, events, 64, -1); + if (nevents == -1) { + if (errno == EINTR) continue; + ALOGE("usb epoll_wait failed; errno=%d", errno); + break; + } + + for (int n = 0; n < nevents; ++n) { + if (events[n].data.ptr) + (*(void (*)(int, struct data *payload))events[n].data.ptr)( + events[n].events, &payload); + } + } + + ALOGI("exiting worker thread"); +error: + close(uevent_fd); + + if (epoll_fd >= 0) close(epoll_fd); + + return NULL; +} + +void sighandler(int sig) { + if (sig == SIGUSR1) { + destroyThread = true; + ALOGI("destroy set"); + return; + } + signal(SIGUSR1, sighandler); +} + +Return Usb::setCallback(const sp &callback) { + pthread_mutex_lock(&mLock); + /* + * When both the old callback and new callback values are NULL, + * there is no need to spin off the worker thread. + * When both the values are not NULL, we would already have a + * worker thread running, so updating the callback object would + * be suffice. + */ + if ((mCallback == NULL && callback == NULL) || + (mCallback != NULL && callback != NULL)) { + mCallback = callback; + pthread_mutex_unlock(&mLock); + return Void(); + } + + mCallback = callback; + ALOGI("registering callback"); + + // Kill the worker thread if the new callback is NULL. + if (mCallback == NULL) { + pthread_mutex_unlock(&mLock); + if (!pthread_kill(mPoll, SIGUSR1)) { + pthread_join(mPoll, NULL); + ALOGI("pthread destroyed"); + } + return Void(); + } + + destroyThread = false; + signal(SIGUSR1, sighandler); + + /* + * Create a background thread if the old callback value is NULL + * and being updated with a new value. + */ + if (pthread_create(&mPoll, NULL, work, this)) { + ALOGE("pthread creation failed %d", errno); + mCallback = NULL; + } + + pthread_mutex_unlock(&mLock); + return Void(); +} + +} // namespace implementation +} // namespace V1_0 +} // namespace usb +} // namespace hardware +} // namespace android diff --git a/hidl/usb/Usb.h b/hidl/usb/Usb.h new file mode 100644 index 0000000..4eaecc5 --- /dev/null +++ b/hidl/usb/Usb.h @@ -0,0 +1,52 @@ +#ifndef ANDROID_HARDWARE_USB_V1_0_USB_H +#define ANDROID_HARDWARE_USB_V1_0_USB_H + +#include +#include +#include +#include + +#ifdef LOG_TAG +#undef LOG_TAG +#endif + +#define LOG_TAG "android.hardware.usb@1.0-service.device" +#define UEVENT_MSG_LEN 2048 + +namespace android { +namespace hardware { +namespace usb { +namespace V1_0 { +namespace implementation { + +using ::android::hardware::usb::V1_0::IUsb; +using ::android::hardware::usb::V1_0::IUsbCallback; +using ::android::hardware::usb::V1_0::PortRole; +using ::android::hidl::base::V1_0::IBase; +using ::android::hardware::hidl_array; +using ::android::hardware::hidl_memory; +using ::android::hardware::hidl_string; +using ::android::hardware::hidl_vec; +using ::android::hardware::Return; +using ::android::hardware::Void; +using ::android::sp; + +struct Usb : public IUsb { + Return switchRole(const hidl_string& portName, const PortRole& role) override; + Return setCallback(const sp& callback) override; + Return queryPortStatus() override; + + sp mCallback; + pthread_mutex_t mLock = PTHREAD_MUTEX_INITIALIZER; + + private: + pthread_t mPoll; +}; + +} // namespace implementation +} // namespace V1_0 +} // namespace usb +} // namespace hardware +} // namespace android + +#endif // ANDROID_HARDWARE_USB_V1_0_USB_H diff --git a/hidl/usb/android.hardware.usb@1.0-service.device.rc b/hidl/usb/android.hardware.usb@1.0-service.device.rc new file mode 100644 index 0000000..dd74760 --- /dev/null +++ b/hidl/usb/android.hardware.usb@1.0-service.device.rc @@ -0,0 +1,10 @@ +service usb-hal-1-0 /vendor/bin/hw/android.hardware.usb@1.0-service.device + class hal + user system + group system + +on boot + chown root system /sys/class/typec/usbc0/current_power_role + chown root system /sys/class/typec/usbc0/current_data_role + chmod 664 /sys/class/typec/usbc0/current_power_role + chmod 664 /sys/class/typec/usbc0/current_data_role diff --git a/hidl/usb/service.cpp b/hidl/usb/service.cpp new file mode 100644 index 0000000..b4db241 --- /dev/null +++ b/hidl/usb/service.cpp @@ -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. + */ + +#include +#include "Usb.h" + +using android::sp; + +// libhwbinder: +using android::hardware::configureRpcThreadpool; +using android::hardware::joinRpcThreadpool; + +// Generated HIDL files +using android::hardware::usb::V1_0::IUsb; +using android::hardware::usb::V1_0::implementation::Usb; + +int main() { + const char instance[] = "usb_hal"; + + android::sp service = new Usb(); + + configureRpcThreadpool(1, true /*callerWillJoin*/); + service->registerAsService(instance); + + ALOGI("USB HAL Ready."); + joinRpcThreadpool(); +} -- 2.20.1