Create aosp_redfin target

Bug: 139478768
Change-Id: I061f89a72b5e7b81280406abf85cca479b86f340

8 files changed, 1429 insertions, 0 deletions

diff --git a/usb/.clang-format b/usb/.clang-format
new file mode 100644
index 0000000..5d8d909
--- /dev/null
+++ b/usb/.clang-format
@@ -0,0 +1,14 @@
+BasedOnStyle: Google
+AccessModifierOffset: -2
+AllowShortFunctionsOnASingleLine: Inline
+ColumnLimit: 99
+CommentPragmas: NOLINT:.*
+DerivePointerAlignment: false
+IndentWidth: 4
+PointerAlignment: Right
+TabWidth: 4
+UseTab: Never
+PenaltyExcessCharacter: 32
+AllowShortIfStatementsOnASingleLine: false
+SpacesBeforeTrailingComments: 2
+
diff --git a/usb/Android.bp b/usb/Android.bp
new file mode 100644
index 0000000..2f7afc2
--- /dev/null
+++ b/usb/Android.bp
@@ -0,0 +1,36 @@
+//
+// Copyright (C) 2018 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.
+
+cc_binary {
+    name: "android.hardware.usb@1.2-service.redfin",
+    relative_install_path: "hw",
+    init_rc: ["android.hardware.usb@1.2-service.redfin.rc"],
+    srcs: ["service.cpp", "Usb.cpp", "UsbGadget.cpp"],
+    shared_libs: [
+        "android.hardware.usb@1.0",
+        "android.hardware.usb@1.1",
+        "android.hardware.usb@1.2",
+        "android.hardware.usb.gadget@1.0",
+        "libbase",
+        "libcutils",
+        "libhardware",
+        "libhidlbase",
+        "libhidltransport",
+        "liblog",
+        "libutils",
+    ],
+    static_libs: ["libpixelusb"],
+    proprietary: true,
+}
diff --git a/usb/Usb.cpp b/usb/Usb.cpp
new file mode 100644
index 0000000..cd0005d
--- /dev/null
+++ b/usb/Usb.cpp
@@ -0,0 +1,785 @@
+/*
+ * 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.
+ */
+
+#define LOG_TAG "android.hardware.usb@1.2-service.redfin"
+
+#include <android-base/logging.h>
+#include <assert.h>
+#include <dirent.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <chrono>
+#include <regex>
+#include <thread>
+#include <unordered_map>
+
+#include <cutils/uevent.h>
+#include <sys/epoll.h>
+#include <utils/Errors.h>
+#include <utils/StrongPointer.h>
+
+#include "Usb.h"
+
+namespace android {
+namespace hardware {
+namespace usb {
+namespace V1_2 {
+namespace implementation {
+
+// Set by the signal handler to destroy the thread
+volatile bool destroyThread;
+
+constexpr char kEnabledPath[] = "/sys/class/power_supply/usb/moisture_detection_enabled";
+constexpr char kDetectedPath[] = "/sys/class/power_supply/usb/moisture_detected";
+
+void queryVersionHelper(android::hardware::usb::V1_2::implementation::Usb *usb,
+                        hidl_vec<PortStatus> *currentPortStatus_1_2);
+
+int32_t readFile(const 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;
+}
+
+int32_t writeFile(const std::string &filename, const std::string &contents) {
+    FILE *fp;
+    std::string written;
+
+    fp = fopen(filename.c_str(), "w");
+    if (fp != NULL) {
+        // FAILURE RETRY
+        int ret = fputs(contents.c_str(), fp);
+        fclose(fp);
+        if ((ret != EOF) && !readFile(filename, &written) && written == contents)
+            return 0;
+    }
+    return -1;
+}
+
+Status queryMoistureDetectionStatus(hidl_vec<PortStatus> *currentPortStatus_1_2) {
+    std::string enabled, status;
+
+    (*currentPortStatus_1_2)[0].supportedContaminantProtectionModes = 0;
+    (*currentPortStatus_1_2)[0].supportedContaminantProtectionModes |=
+        ContaminantProtectionMode::FORCE_SINK;
+    (*currentPortStatus_1_2)[0].contaminantProtectionStatus = ContaminantProtectionStatus::NONE;
+    (*currentPortStatus_1_2)[0].contaminantDetectionStatus = ContaminantDetectionStatus::DISABLED;
+    (*currentPortStatus_1_2)[0].supportsEnableContaminantPresenceDetection = true;
+    (*currentPortStatus_1_2)[0].supportsEnableContaminantPresenceProtection = false;
+
+    if (readFile(kEnabledPath, &enabled)) {
+        ALOGE("Failed to open moisture_detection_enabled");
+        return Status::ERROR;
+    }
+
+    if (enabled == "1") {
+        if (readFile(kDetectedPath, &status)) {
+            ALOGE("Failed to open moisture_detected");
+            return Status::ERROR;
+        }
+        if (status == "1") {
+            (*currentPortStatus_1_2)[0].contaminantDetectionStatus =
+                ContaminantDetectionStatus::DETECTED;
+            (*currentPortStatus_1_2)[0].contaminantProtectionStatus =
+                ContaminantProtectionStatus::FORCE_SINK;
+        } else
+            (*currentPortStatus_1_2)[0].contaminantDetectionStatus =
+                ContaminantDetectionStatus::NOT_DETECTED;
+    }
+
+     ALOGI("ContaminantDetectionStatus:%d ContaminantProtectionStatus:%d",
+	   (*currentPortStatus_1_2)[0].contaminantDetectionStatus,
+	   (*currentPortStatus_1_2)[0].contaminantProtectionStatus);
+
+    return Status::SUCCESS;
+}
+
+Return<void> Usb::enableContaminantPresenceDetection(const hidl_string & /*portName*/,
+                                                     bool enable) {
+    writeFile(kEnabledPath, enable ? "1" : "0");
+    hidl_vec<PortStatus> currentPortStatus_1_2;
+
+    queryVersionHelper(this, &currentPortStatus_1_2);
+    return Void();
+}
+
+Return<void> Usb::enableContaminantPresenceProtection(const hidl_string & /*portName*/,
+                                                      bool /*enable*/) {
+    hidl_vec<PortStatus> currentPortStatus_1_2;
+
+    queryVersionHelper(this, &currentPortStatus_1_2);
+    return Void();
+}
+
+std::string appendRoleNodeHelper(const std::string &portName, PortRoleType type) {
+    std::string node("/sys/class/typec/" + portName);
+
+    switch (type) {
+        case PortRoleType::DATA_ROLE:
+            return node + "/data_role";
+        case PortRoleType::POWER_ROLE:
+            return node + "/power_role";
+        case PortRoleType::MODE:
+            return node + "/port_type";
+        default:
+            return "";
+    }
+}
+
+std::string convertRoletoString(PortRole role) {
+    if (role.type == PortRoleType::POWER_ROLE) {
+        if (role.role == static_cast<uint32_t>(PortPowerRole::SOURCE))
+            return "source";
+        else if (role.role == static_cast<uint32_t>(PortPowerRole::SINK))
+            return "sink";
+    } else if (role.type == PortRoleType::DATA_ROLE) {
+        if (role.role == static_cast<uint32_t>(PortDataRole::HOST))
+            return "host";
+        if (role.role == static_cast<uint32_t>(PortDataRole::DEVICE))
+            return "device";
+    } else if (role.type == PortRoleType::MODE) {
+        if (role.role == static_cast<uint32_t>(PortMode_1_1::UFP))
+            return "sink";
+        if (role.role == static_cast<uint32_t>(PortMode_1_1::DFP))
+            return "source";
+    }
+    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);
+    }
+}
+
+void switchToDrp(const std::string &portName) {
+    std::string filename = appendRoleNodeHelper(std::string(portName.c_str()), PortRoleType::MODE);
+    FILE *fp;
+
+    if (filename != "") {
+        fp = fopen(filename.c_str(), "w");
+        if (fp != NULL) {
+            int ret = fputs("dual", fp);
+            fclose(fp);
+            if (ret == EOF)
+                ALOGE("Fatal: Error while switching back to drp");
+        } else {
+            ALOGE("Fatal: Cannot open file to switch back to drp");
+        }
+    } else {
+        ALOGE("Fatal: invalid node type");
+    }
+}
+
+bool switchMode(const hidl_string &portName, const PortRole &newRole, struct Usb *usb) {
+    std::string filename = appendRoleNodeHelper(std::string(portName.c_str()), newRole.type);
+    std::string written;
+    FILE *fp;
+    bool roleSwitch = false;
+
+    if (filename == "") {
+        ALOGE("Fatal: invalid node type");
+        return false;
+    }
+
+    fp = fopen(filename.c_str(), "w");
+    if (fp != NULL) {
+        // Hold the lock here to prevent loosing connected signals
+        // as once the file is written the partner added signal
+        // can arrive anytime.
+        pthread_mutex_lock(&usb->mPartnerLock);
+        usb->mPartnerUp = false;
+        int ret = fputs(convertRoletoString(newRole).c_str(), fp);
+        fclose(fp);
+
+        if (ret != EOF) {
+            struct timespec to;
+            struct timespec now;
+
+        wait_again:
+            clock_gettime(CLOCK_MONOTONIC, &now);
+            to.tv_sec = now.tv_sec + PORT_TYPE_TIMEOUT;
+            to.tv_nsec = now.tv_nsec;
+
+            int err = pthread_cond_timedwait(&usb->mPartnerCV, &usb->mPartnerLock, &to);
+            // There are no uevent signals which implies role swap timed out.
+            if (err == ETIMEDOUT) {
+                ALOGI("uevents wait timedout");
+                // Sanity check.
+            } else if (!usb->mPartnerUp) {
+                goto wait_again;
+                // Role switch succeeded since usb->mPartnerUp is true.
+            } else {
+                roleSwitch = true;
+            }
+        } else {
+            ALOGI("Role switch failed while wrting to file");
+        }
+        pthread_mutex_unlock(&usb->mPartnerLock);
+    }
+
+    if (!roleSwitch)
+        switchToDrp(std::string(portName.c_str()));
+
+    return roleSwitch;
+}
+
+Usb::Usb()
+    : mLock(PTHREAD_MUTEX_INITIALIZER),
+      mRoleSwitchLock(PTHREAD_MUTEX_INITIALIZER),
+      mPartnerLock(PTHREAD_MUTEX_INITIALIZER),
+      mPartnerUp(false) {
+    pthread_condattr_t attr;
+    if (pthread_condattr_init(&attr)) {
+        ALOGE("pthread_condattr_init failed: %s", strerror(errno));
+        abort();
+    }
+    if (pthread_condattr_setclock(&attr, CLOCK_MONOTONIC)) {
+        ALOGE("pthread_condattr_setclock failed: %s", strerror(errno));
+        abort();
+    }
+    if (pthread_cond_init(&mPartnerCV, &attr)) {
+        ALOGE("pthread_cond_init failed: %s", strerror(errno));
+        abort();
+    }
+    if (pthread_condattr_destroy(&attr)) {
+        ALOGE("pthread_condattr_destroy failed: %s", strerror(errno));
+        abort();
+    }
+}
+
+Return<void> Usb::switchRole(const hidl_string &portName, const V1_0::PortRole &newRole) {
+    std::string filename = appendRoleNodeHelper(std::string(portName.c_str()), newRole.type);
+    std::string written;
+    FILE *fp;
+    bool roleSwitch = false;
+
+    if (filename == "") {
+        ALOGE("Fatal: invalid node type");
+        return Void();
+    }
+
+    pthread_mutex_lock(&mRoleSwitchLock);
+
+    ALOGI("filename write: %s role:%s", filename.c_str(), convertRoletoString(newRole).c_str());
+
+    if (newRole.type == PortRoleType::MODE) {
+        roleSwitch = switchMode(portName, newRole, this);
+    } else {
+        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)) {
+                    roleSwitch = true;
+                } else {
+                    ALOGE("Role switch failed");
+                }
+            } else {
+                ALOGE("failed to update the new role");
+            }
+        } else {
+            ALOGE("fopen failed");
+        }
+    }
+
+    pthread_mutex_lock(&mLock);
+    if (mCallback_1_0 != NULL) {
+        Return<void> ret = mCallback_1_0->notifyRoleSwitchStatus(
+            portName, newRole, roleSwitch ? Status::SUCCESS : 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);
+    pthread_mutex_unlock(&mRoleSwitchLock);
+
+    return Void();
+}
+
+Status getAccessoryConnected(const std::string &portName, std::string *accessory) {
+    std::string filename = "/sys/class/typec/" + portName + "-partner/accessory_mode";
+
+    if (readFile(filename, accessory)) {
+        ALOGE("getAccessoryConnected: Failed to open filesystem node: %s", filename.c_str());
+        return Status::ERROR;
+    }
+
+    return Status::SUCCESS;
+}
+
+Status getCurrentRoleHelper(const std::string &portName, bool connected, PortRoleType type,
+                            uint32_t *currentRole) {
+    std::string filename;
+    std::string roleName;
+    std::string accessory;
+
+    // Mode
+
+    if (type == PortRoleType::POWER_ROLE) {
+        filename = "/sys/class/typec/" + portName + "/power_role";
+        *currentRole = static_cast<uint32_t>(PortPowerRole::NONE);
+    } else if (type == PortRoleType::DATA_ROLE) {
+        filename = "/sys/class/typec/" + portName + "/data_role";
+        *currentRole = static_cast<uint32_t>(PortDataRole::NONE);
+    } else if (type == PortRoleType::MODE) {
+        filename = "/sys/class/typec/" + portName + "/data_role";
+        *currentRole = static_cast<uint32_t>(PortMode_1_1::NONE);
+    } else {
+        return Status::ERROR;
+    }
+
+    if (!connected)
+        return Status::SUCCESS;
+
+    if (type == PortRoleType::MODE) {
+        if (getAccessoryConnected(portName, &accessory) != Status::SUCCESS) {
+            return Status::ERROR;
+        }
+        if (accessory == "analog_audio") {
+            *currentRole = static_cast<uint32_t>(PortMode_1_1::AUDIO_ACCESSORY);
+            return Status::SUCCESS;
+        } else if (accessory == "debug") {
+            *currentRole = static_cast<uint32_t>(PortMode_1_1::DEBUG_ACCESSORY);
+            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<uint32_t>(PortPowerRole::SOURCE);
+    } else if (roleName == "sink") {
+        *currentRole = static_cast<uint32_t>(PortPowerRole::SINK);
+    } else if (roleName == "host") {
+        if (type == PortRoleType::DATA_ROLE)
+            *currentRole = static_cast<uint32_t>(PortDataRole::HOST);
+        else
+            *currentRole = static_cast<uint32_t>(PortMode_1_1::DFP);
+    } else if (roleName == "device") {
+        if (type == PortRoleType::DATA_ROLE)
+            *currentRole = static_cast<uint32_t>(PortDataRole::DEVICE);
+        else
+            *currentRole = static_cast<uint32_t>(PortMode_1_1::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<std::string, bool> *names) {
+    DIR *dp;
+
+    dp = opendir("/sys/class/typec");
+    if (dp != NULL) {
+        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<std::string, bool>::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 == "yes") {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+/*
+ * Reuse the same method for both V1_0 and V1_1 callback objects.
+ * The caller of this method would reconstruct the V1_0::PortStatus
+ * object if required.
+ */
+Status getPortStatusHelper(hidl_vec<PortStatus> *currentPortStatus_1_2, HALVersion version) {
+    std::unordered_map<std::string, bool> names;
+    Status result = getTypeCPortNamesHelper(&names);
+    int i = -1;
+
+    if (result == Status::SUCCESS) {
+        currentPortStatus_1_2->resize(names.size());
+        for (std::pair<std::string, bool> port : names) {
+            i++;
+            ALOGI("%s", port.first.c_str());
+            (*currentPortStatus_1_2)[i].status_1_1.status.portName = port.first;
+
+            uint32_t currentRole;
+            if (getCurrentRoleHelper(port.first, port.second, PortRoleType::POWER_ROLE,
+                                     &currentRole) == Status::SUCCESS) {
+                (*currentPortStatus_1_2)[i].status_1_1.status.currentPowerRole =
+                    static_cast<PortPowerRole>(currentRole);
+            } else {
+                ALOGE("Error while retreiving portNames");
+                goto done;
+            }
+
+            if (getCurrentRoleHelper(port.first, port.second, PortRoleType::DATA_ROLE,
+                                     &currentRole) == Status::SUCCESS) {
+                (*currentPortStatus_1_2)[i].status_1_1.status.currentDataRole =
+                    static_cast<PortDataRole>(currentRole);
+            } else {
+                ALOGE("Error while retreiving current port role");
+                goto done;
+            }
+
+            if (getCurrentRoleHelper(port.first, port.second, PortRoleType::MODE, &currentRole) ==
+                Status::SUCCESS) {
+                (*currentPortStatus_1_2)[i].status_1_1.currentMode =
+                    static_cast<PortMode_1_1>(currentRole);
+                (*currentPortStatus_1_2)[i].status_1_1.status.currentMode =
+                    static_cast<V1_0::PortMode>(currentRole);
+            } else {
+                ALOGE("Error while retreiving current data role");
+                goto done;
+            }
+
+            (*currentPortStatus_1_2)[i].status_1_1.status.canChangeMode = true;
+            (*currentPortStatus_1_2)[i].status_1_1.status.canChangeDataRole =
+                port.second ? canSwitchRoleHelper(port.first, PortRoleType::DATA_ROLE) : false;
+            (*currentPortStatus_1_2)[i].status_1_1.status.canChangePowerRole =
+                port.second ? canSwitchRoleHelper(port.first, PortRoleType::POWER_ROLE) : false;
+
+            if (version == HALVersion::V1_0) {
+                ALOGI("HAL version V1_0");
+                (*currentPortStatus_1_2)[i].status_1_1.status.supportedModes = V1_0::PortMode::DRP;
+            } else {
+		if (version == HALVersion::V1_1)
+                    ALOGI("HAL version V1_1");
+		else
+                    ALOGI("HAL version V1_2");
+                (*currentPortStatus_1_2)[i].status_1_1.supportedModes = 0 | PortMode_1_1::DRP;
+                (*currentPortStatus_1_2)[i].status_1_1.status.supportedModes = V1_0::PortMode::NONE;
+                (*currentPortStatus_1_2)[i].status_1_1.status.currentMode = V1_0::PortMode::NONE;
+            }
+
+            ALOGI(
+                "%d:%s connected:%d canChangeMode:%d canChagedata:%d canChangePower:%d "
+                "supportedModes:%d",
+                i, port.first.c_str(), port.second,
+                (*currentPortStatus_1_2)[i].status_1_1.status.canChangeMode,
+                (*currentPortStatus_1_2)[i].status_1_1.status.canChangeDataRole,
+                (*currentPortStatus_1_2)[i].status_1_1.status.canChangePowerRole,
+                (*currentPortStatus_1_2)[i].status_1_1.supportedModes);
+        }
+        return Status::SUCCESS;
+    }
+done:
+    return Status::ERROR;
+}
+
+void queryVersionHelper(android::hardware::usb::V1_2::implementation::Usb *usb,
+                        hidl_vec<PortStatus> *currentPortStatus_1_2) {
+    hidl_vec<V1_1::PortStatus_1_1> currentPortStatus_1_1;
+    hidl_vec<V1_0::PortStatus> currentPortStatus;
+    Status status;
+    sp<V1_1::IUsbCallback> callback_V1_1 = V1_1::IUsbCallback::castFrom(usb->mCallback_1_0);
+    sp<IUsbCallback> callback_V1_2 = IUsbCallback::castFrom(usb->mCallback_1_0);
+
+    pthread_mutex_lock(&usb->mLock);
+    if (usb->mCallback_1_0 != NULL) {
+        if (callback_V1_2 != NULL) {
+            status = getPortStatusHelper(currentPortStatus_1_2, HALVersion::V1_2);
+            queryMoistureDetectionStatus(currentPortStatus_1_2);
+        } else if (callback_V1_1 != NULL) {
+            status = getPortStatusHelper(currentPortStatus_1_2, HALVersion::V1_1);
+            currentPortStatus_1_1.resize(currentPortStatus_1_2->size());
+            for (unsigned long i = 0; i < currentPortStatus_1_2->size(); i++)
+                currentPortStatus_1_1[i] = (*currentPortStatus_1_2)[i].status_1_1;
+        } else {
+            status = getPortStatusHelper(currentPortStatus_1_2, HALVersion::V1_0);
+            currentPortStatus.resize(currentPortStatus_1_2->size());
+            for (unsigned long i = 0; i < currentPortStatus_1_2->size(); i++)
+                currentPortStatus[i] = (*currentPortStatus_1_2)[i].status_1_1.status;
+        }
+
+        Return<void> ret;
+
+        if (callback_V1_2 != NULL)
+            ret = callback_V1_2->notifyPortStatusChange_1_2(*currentPortStatus_1_2, status);
+        else if (callback_V1_1 != NULL)
+            ret = callback_V1_1->notifyPortStatusChange_1_1(currentPortStatus_1_1, status);
+        else
+            ret = usb->mCallback_1_0->notifyPortStatusChange(currentPortStatus, status);
+
+        if (!ret.isOk())
+            ALOGE("queryPortStatus_1_2 error %s", ret.description().c_str());
+    } else {
+        ALOGI("Notifying userspace skipped. Callback is NULL");
+    }
+    pthread_mutex_unlock(&usb->mLock);
+}
+
+Return<void> Usb::queryPortStatus() {
+    hidl_vec<PortStatus> currentPortStatus_1_2;
+
+    queryVersionHelper(this, &currentPortStatus_1_2);
+    return Void();
+}
+
+struct data {
+    int uevent_fd;
+    android::hardware::usb::V1_2::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 (std::regex_match(cp, std::regex("(add)(.*)(-partner)"))) {
+            ALOGI("partner added");
+            pthread_mutex_lock(&payload->usb->mPartnerLock);
+            payload->usb->mPartnerUp = true;
+            pthread_cond_signal(&payload->usb->mPartnerCV);
+            pthread_mutex_unlock(&payload->usb->mPartnerLock);
+        } else if (!strncmp(cp, "DEVTYPE=typec_", strlen("DEVTYPE=typec_")) ||
+                   !strncmp(cp, "POWER_SUPPLY_MOISTURE_DETECTED",
+                            strlen("POWER_SUPPLY_MOISTURE_DETECTED"))) {
+            hidl_vec<PortStatus> currentPortStatus_1_2;
+            queryVersionHelper(payload->usb, &currentPortStatus_1_2);
+
+            // Role switch is not in progress and port is in disconnected state
+            if (!pthread_mutex_trylock(&payload->usb->mRoleSwitchLock)) {
+                for (unsigned long i = 0; i < currentPortStatus_1_2.size(); i++) {
+                    DIR *dp =
+                        opendir(std::string("/sys/class/typec/" +
+                                            std::string(currentPortStatus_1_2[i]
+                                                            .status_1_1.status.portName.c_str()) +
+                                            "-partner")
+                                    .c_str());
+                    if (dp == NULL) {
+                        // PortRole role = {.role = static_cast<uint32_t>(PortMode::UFP)};
+                        switchToDrp(currentPortStatus_1_2[i].status_1_1.status.portName);
+                    } else {
+                        closedir(dp);
+                    }
+                }
+                pthread_mutex_unlock(&payload->usb->mRoleSwitchLock);
+            }
+            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_2::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<void> Usb::setCallback(const sp<V1_0::IUsbCallback> &callback) {
+    sp<V1_1::IUsbCallback> callback_V1_1 = V1_1::IUsbCallback::castFrom(callback);
+    sp<IUsbCallback> callback_V1_2 = IUsbCallback::castFrom(callback);
+
+    if (callback != NULL) {
+        if (callback_V1_2 != NULL)
+            ALOGI("Registering 1.2 callback");
+        else if (callback_V1_1 != NULL)
+            ALOGI("Registering 1.1 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_1_0 == NULL && callback == NULL) ||
+        (mCallback_1_0 != NULL && callback != NULL)) {
+        /*
+         * Always store as V1_0 callback object. Type cast to V1_1
+         * when the callback is actually invoked.
+         */
+        mCallback_1_0 = callback;
+        pthread_mutex_unlock(&mLock);
+        return Void();
+    }
+
+    mCallback_1_0 = callback;
+    ALOGI("registering callback");
+
+    // Kill the worker thread if the new callback is NULL.
+    if (mCallback_1_0 == 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_1_0 = NULL;
+    }
+
+    pthread_mutex_unlock(&mLock);
+    return Void();
+}
+
+}  // namespace implementation
+}  // namespace V1_2
+}  // namespace usb
+}  // namespace hardware
+}  // namespace android
diff --git a/usb/Usb.h b/usb/Usb.h
new file mode 100644
index 0000000..65be180
--- /dev/null
+++ b/usb/Usb.h
@@ -0,0 +1,81 @@
+#ifndef ANDROID_HARDWARE_USB_V1_1_USB_H
+#define ANDROID_HARDWARE_USB_V1_1_USB_H
+
+#include <android/hardware/usb/1.2/IUsb.h>
+#include <android/hardware/usb/1.2/IUsbCallback.h>
+#include <android/hardware/usb/1.2/types.h>
+#include <hidl/Status.h>
+#include <utils/Log.h>
+
+#define UEVENT_MSG_LEN 2048
+// The type-c stack waits for 4.5 - 5.5 secs before declaring a port non-pd.
+// The -partner directory would not be created until this is done.
+// Having a margin of ~3 secs for the directory and other related bookeeping
+// structures created and uvent fired.
+#define PORT_TYPE_TIMEOUT 8
+
+namespace android {
+namespace hardware {
+namespace usb {
+namespace V1_2 {
+namespace implementation {
+
+using ::android::sp;
+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::hardware::usb::V1_0::PortDataRole;
+using ::android::hardware::usb::V1_0::PortPowerRole;
+using ::android::hardware::usb::V1_0::PortRole;
+using ::android::hardware::usb::V1_0::PortRoleType;
+using ::android::hardware::usb::V1_0::Status;
+using ::android::hardware::usb::V1_2::IUsb;
+using ::android::hardware::usb::V1_2::IUsbCallback;
+
+using ::android::hardware::usb::V1_1::PortMode_1_1;
+using ::android::hardware::usb::V1_1::PortStatus_1_1;
+using ::android::hardware::usb::V1_2::PortStatus;
+using ::android::hidl::base::V1_0::DebugInfo;
+using ::android::hidl::base::V1_0::IBase;
+
+enum class HALVersion{
+    V1_0,
+    V1_1,
+    V1_2
+};
+
+struct Usb : public IUsb {
+    Usb();
+
+    Return<void> switchRole(const hidl_string &portName, const V1_0::PortRole &role) override;
+    Return<void> setCallback(const sp<V1_0::IUsbCallback> &callback) override;
+    Return<void> queryPortStatus() override;
+    Return<void> enableContaminantPresenceDetection(const hidl_string& portName, bool enable);
+    Return<void> enableContaminantPresenceProtection(const hidl_string& portName, bool enable);
+
+    sp<V1_0::IUsbCallback> mCallback_1_0;
+    // Protects mCallback variable
+    pthread_mutex_t mLock;
+    // Protects roleSwitch operation
+    pthread_mutex_t mRoleSwitchLock;
+    // Threads waiting for the partner to come back wait here
+    pthread_cond_t mPartnerCV;
+    // lock protecting mPartnerCV
+    pthread_mutex_t mPartnerLock;
+    // Variable to signal partner coming back online after type switch
+    bool mPartnerUp;
+
+  private:
+    pthread_t mPoll;
+};
+
+}  // namespace implementation
+}  // namespace V1_2
+}  // namespace usb
+}  // namespace hardware
+}  // namespace android
+
+#endif  // ANDROID_HARDWARE_USB_V1_2_USB_H
diff --git a/usb/UsbGadget.cpp b/usb/UsbGadget.cpp
new file mode 100644
index 0000000..86a305b
--- /dev/null
+++ b/usb/UsbGadget.cpp
@@ -0,0 +1,344 @@
+/*
+ * Copyright (C) 2018 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.
+ */
+
+#define LOG_TAG "android.hardware.usb.gadget@1.0-service.redfin"
+
+#include "UsbGadget.h"
+#include <dirent.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <sys/inotify.h>
+#include <sys/mount.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+namespace android {
+namespace hardware {
+namespace usb {
+namespace gadget {
+namespace V1_0 {
+namespace implementation {
+
+UsbGadget::UsbGadget() {
+    if (access(OS_DESC_PATH, R_OK) != 0) {
+        ALOGE("configfs setup not done yet");
+        abort();
+    }
+}
+
+void currentFunctionsAppliedCallback(bool functionsApplied, void *payload) {
+    UsbGadget *gadget = (UsbGadget *)payload;
+    gadget->mCurrentUsbFunctionsApplied = functionsApplied;
+}
+
+Return<void> UsbGadget::getCurrentUsbFunctions(const sp<V1_0::IUsbGadgetCallback> &callback) {
+    Return<void> ret = callback->getCurrentUsbFunctionsCb(
+        mCurrentUsbFunctions,
+        mCurrentUsbFunctionsApplied ? Status::FUNCTIONS_APPLIED : Status::FUNCTIONS_NOT_APPLIED);
+    if (!ret.isOk())
+        ALOGE("Call to getCurrentUsbFunctionsCb failed %s", ret.description().c_str());
+
+    return Void();
+}
+
+V1_0::Status UsbGadget::tearDownGadget() {
+    if (resetGadget() != Status::SUCCESS)
+        return Status::ERROR;
+
+    if (monitorFfs.isMonitorRunning()) {
+        monitorFfs.reset();
+    } else {
+        ALOGI("mMonitor not running");
+    }
+    return Status::SUCCESS;
+}
+
+static V1_0::Status validateAndSetVidPid(uint64_t functions) {
+    V1_0::Status ret = Status::SUCCESS;
+    std::string vendorFunctions = getVendorFunctions();
+
+    switch (functions) {
+        case static_cast<uint64_t>(GadgetFunction::MTP):
+            if (vendorFunctions == "diag") {
+                ret = setVidPid("0x05C6", "0x901B");
+            } else {
+                if (!(vendorFunctions == "user" || vendorFunctions == "")) {
+                    ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
+                    ret = Status::CONFIGURATION_NOT_SUPPORTED;
+                } else {
+                    ret = setVidPid("0x18d1", "0x4ee1");
+                }
+            }
+            break;
+        case GadgetFunction::ADB | GadgetFunction::MTP:
+            if (vendorFunctions == "diag") {
+                ret = setVidPid("0x05C6", "0x903A");
+            } else {
+                if (!(vendorFunctions == "user" || vendorFunctions == "")) {
+                    ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
+                    ret = Status::CONFIGURATION_NOT_SUPPORTED;
+                } else {
+                    ret = setVidPid("0x18d1", "0x4ee2");
+                }
+            }
+            break;
+        case static_cast<uint64_t>(GadgetFunction::RNDIS):
+            if (vendorFunctions == "diag") {
+                ret = setVidPid("0x05C6", "0x902C");
+            } else if (vendorFunctions == "serial_cdev,diag") {
+                ret = setVidPid("0x05C6", "0x90B5");
+            } else if (vendorFunctions == "diag,diag_mdm,qdss,qdss_mdm,serial_cdev,dpl_gsi") {
+                ret = setVidPid("0x05C6", "0x90E6");
+            } else {
+                if (!(vendorFunctions == "user" || vendorFunctions == "")) {
+                    ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
+                    ret = Status::CONFIGURATION_NOT_SUPPORTED;
+                } else {
+                    ret = setVidPid("0x18d1", "0x4ee3");
+                }
+            }
+            break;
+        case GadgetFunction::ADB | GadgetFunction::RNDIS:
+            if (vendorFunctions == "diag") {
+                ret = setVidPid("0x05C6", "0x902D");
+            } else if (vendorFunctions == "serial_cdev,diag") {
+                ret = setVidPid("0x05C6", "0x90B6");
+            } else if (vendorFunctions == "diag,diag_mdm,qdss,qdss_mdm,serial_cdev,dpl_gsi") {
+                ret = setVidPid("0x05C6", "0x90E7");
+            } else {
+                if (!(vendorFunctions == "user" || vendorFunctions == "")) {
+                    ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
+                    ret = Status::CONFIGURATION_NOT_SUPPORTED;
+                } else {
+                    ret = setVidPid("0x18d1", "0x4ee4");
+                }
+            }
+            break;
+        case static_cast<uint64_t>(GadgetFunction::PTP):
+            if (!(vendorFunctions == "user" || vendorFunctions == "")) {
+                ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
+                ret = Status::CONFIGURATION_NOT_SUPPORTED;
+            } else {
+                ret = setVidPid("0x18d1", "0x4ee5");
+            }
+            break;
+        case GadgetFunction::ADB | GadgetFunction::PTP:
+            if (!(vendorFunctions == "user" || vendorFunctions == "")) {
+                ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
+                ret = Status::CONFIGURATION_NOT_SUPPORTED;
+            } else {
+                ret = setVidPid("0x18d1", "0x4ee6");
+            }
+            break;
+        case static_cast<uint64_t>(GadgetFunction::ADB):
+            if (vendorFunctions == "diag") {
+                ret = setVidPid("0x05C6", "0x901D");
+            } else if (vendorFunctions == "diag,serial_cdev,rmnet_gsi") {
+                ret = setVidPid("0x05C6", "0x9091");
+            } else if (vendorFunctions == "diag,serial_cdev") {
+                ret = setVidPid("0x05C6", "0x901F");
+            } else if (vendorFunctions ==
+                       "diag,diag_mdm,qdss,qdss_mdm,serial_cdev,dpl_gsi,rmnet_gsi") {
+                ret = setVidPid("0x05C6", "0x90E5");
+            } else {
+                if (!(vendorFunctions == "user" || vendorFunctions == "")) {
+                    ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
+                    ret = Status::CONFIGURATION_NOT_SUPPORTED;
+                } else {
+                    ret = setVidPid("0x18d1", "0x4ee7");
+                }
+            }
+            break;
+        case static_cast<uint64_t>(GadgetFunction::MIDI):
+            if (!(vendorFunctions == "user" || vendorFunctions == "")) {
+                ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
+                ret = Status::CONFIGURATION_NOT_SUPPORTED;
+            } else {
+                ret = setVidPid("0x18d1", "0x4ee8");
+            }
+            break;
+        case GadgetFunction::ADB | GadgetFunction::MIDI:
+            if (!(vendorFunctions == "user" || vendorFunctions == "")) {
+                ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
+                ret = Status::CONFIGURATION_NOT_SUPPORTED;
+            } else {
+                ret = setVidPid("0x18d1", "0x4ee9");
+            }
+            break;
+        case static_cast<uint64_t>(GadgetFunction::ACCESSORY):
+            if (!(vendorFunctions == "user" || vendorFunctions == ""))
+                ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
+            ret = setVidPid("0x18d1", "0x2d00");
+            break;
+        case GadgetFunction::ADB | GadgetFunction::ACCESSORY:
+            if (!(vendorFunctions == "user" || vendorFunctions == ""))
+                ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
+            ret = setVidPid("0x18d1", "0x2d01");
+            break;
+        case static_cast<uint64_t>(GadgetFunction::AUDIO_SOURCE):
+            if (!(vendorFunctions == "user" || vendorFunctions == ""))
+                ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
+            ret = setVidPid("0x18d1", "0x2d02");
+            break;
+        case GadgetFunction::ADB | GadgetFunction::AUDIO_SOURCE:
+            if (!(vendorFunctions == "user" || vendorFunctions == ""))
+                ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
+            ret = setVidPid("0x18d1", "0x2d03");
+            break;
+        case GadgetFunction::ACCESSORY | GadgetFunction::AUDIO_SOURCE:
+            if (!(vendorFunctions == "user" || vendorFunctions == ""))
+                ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
+            ret = setVidPid("0x18d1", "0x2d04");
+            break;
+        case GadgetFunction::ADB | GadgetFunction::ACCESSORY | GadgetFunction::AUDIO_SOURCE:
+            if (!(vendorFunctions == "user" || vendorFunctions == ""))
+                ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
+            ret = setVidPid("0x18d1", "0x2d05");
+            break;
+        default:
+            ALOGE("Combination not supported");
+            ret = Status::CONFIGURATION_NOT_SUPPORTED;
+    }
+    return ret;
+}
+
+V1_0::Status UsbGadget::setupFunctions(uint64_t functions,
+                                       const sp<V1_0::IUsbGadgetCallback> &callback,
+                                       uint64_t timeout) {
+    bool ffsEnabled = false;
+    int i = 0;
+
+    if (addGenericAndroidFunctions(&monitorFfs, functions, &ffsEnabled, &i) != Status::SUCCESS)
+        return Status::ERROR;
+
+    std::string vendorFunctions = getVendorFunctions();
+
+    if (vendorFunctions != "") {
+        ALOGI("enable usbradio debug functions");
+        char *function = strtok(const_cast<char *>(vendorFunctions.c_str()), ",");
+        while (function != NULL) {
+            if (string(function) == "diag" && linkFunction("diag.diag", i++))
+                return Status::ERROR;
+            if (string(function) == "diag_mdm" && linkFunction("diag.diag_mdm", i++))
+                return Status::ERROR;
+            if (string(function) == "qdss" && linkFunction("qdss.qdss", i++))
+                return Status::ERROR;
+            if (string(function) == "qdss_mdm" && linkFunction("qdss.qdss_mdm", i++))
+                return Status::ERROR;
+            if (string(function) == "serial_cdev" && linkFunction("cser.dun.0", i++))
+                return Status::ERROR;
+            if (string(function) == "dpl_gsi" && linkFunction("gsi.dpl", i++))
+                return Status::ERROR;
+            if (string(function) == "rmnet_gsi" && linkFunction("gsi.rmnet", i++))
+                return Status::ERROR;
+            function = strtok(NULL, ",");
+        }
+    }
+
+    if ((functions & GadgetFunction::ADB) != 0) {
+        ffsEnabled = true;
+        if (addAdb(&monitorFfs, &i) != Status::SUCCESS)
+            return Status::ERROR;
+    }
+
+    // Pull up the gadget right away when there are no ffs functions.
+    if (!ffsEnabled) {
+        if (!WriteStringToFile(kGadgetName, PULLUP_PATH))
+            return Status::ERROR;
+        mCurrentUsbFunctionsApplied = true;
+        if (callback)
+            callback->setCurrentUsbFunctionsCb(functions, Status::SUCCESS);
+        return Status::SUCCESS;
+    }
+
+    monitorFfs.registerFunctionsAppliedCallback(&currentFunctionsAppliedCallback, this);
+    // Monitors the ffs paths to pull up the gadget when descriptors are written.
+    // Also takes of the pulling up the gadget again if the userspace process
+    // dies and restarts.
+    monitorFfs.startMonitor();
+
+    if (kDebug)
+        ALOGI("Mainthread in Cv");
+
+    if (callback) {
+        bool pullup = monitorFfs.waitForPullUp(timeout);
+        Return<void> ret = callback->setCurrentUsbFunctionsCb(
+            functions, pullup ? Status::SUCCESS : Status::ERROR);
+        if (!ret.isOk())
+            ALOGE("setCurrentUsbFunctionsCb error %s", ret.description().c_str());
+    }
+
+    return Status::SUCCESS;
+}
+
+Return<void> UsbGadget::setCurrentUsbFunctions(uint64_t functions,
+                                               const sp<V1_0::IUsbGadgetCallback> &callback,
+                                               uint64_t timeout) {
+    std::unique_lock<std::mutex> lk(mLockSetCurrentFunction);
+
+    mCurrentUsbFunctions = functions;
+    mCurrentUsbFunctionsApplied = false;
+
+    // Unlink the gadget and stop the monitor if running.
+    V1_0::Status status = tearDownGadget();
+    if (status != Status::SUCCESS) {
+        goto error;
+    }
+
+    ALOGI("Returned from tearDown gadget");
+
+    // Leave the gadget pulled down to give time for the host to sense disconnect.
+    usleep(kDisconnectWaitUs);
+
+    if (functions == static_cast<uint64_t>(GadgetFunction::NONE)) {
+        if (callback == NULL)
+            return Void();
+        Return<void> ret = callback->setCurrentUsbFunctionsCb(functions, Status::SUCCESS);
+        if (!ret.isOk())
+            ALOGE("Error while calling setCurrentUsbFunctionsCb %s", ret.description().c_str());
+        return Void();
+    }
+
+    status = validateAndSetVidPid(functions);
+
+    if (status != Status::SUCCESS) {
+        goto error;
+    }
+
+    status = setupFunctions(functions, callback, timeout);
+    if (status != Status::SUCCESS) {
+        goto error;
+    }
+
+    ALOGI("Usb Gadget setcurrent functions called successfully");
+    return Void();
+
+error:
+    ALOGI("Usb Gadget setcurrent functions failed");
+    if (callback == NULL)
+        return Void();
+    Return<void> ret = callback->setCurrentUsbFunctionsCb(functions, status);
+    if (!ret.isOk())
+        ALOGE("Error while calling setCurrentUsbFunctionsCb %s", ret.description().c_str());
+    return Void();
+}
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace gadget
+}  // namespace usb
+}  // namespace hardware
+}  // namespace android
diff --git a/usb/UsbGadget.h b/usb/UsbGadget.h
new file mode 100644
index 0000000..1ffb188
--- /dev/null
+++ b/usb/UsbGadget.h
@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2018 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_HARDWARE_USB_GADGET_V1_0_USBGADGET_H
+#define ANDROID_HARDWARE_USB_GADGET_V1_0_USBGADGET_H
+
+#include <android-base/file.h>
+#include <android-base/properties.h>
+#include <android-base/unique_fd.h>
+#include <android/hardware/usb/gadget/1.0/IUsbGadget.h>
+#include <hidl/MQDescriptor.h>
+#include <hidl/Status.h>
+#include <pixelusb/UsbGadgetCommon.h>
+#include <sys/epoll.h>
+#include <sys/eventfd.h>
+#include <utils/Log.h>
+#include <chrono>
+#include <condition_variable>
+#include <mutex>
+#include <string>
+#include <thread>
+
+namespace android {
+namespace hardware {
+namespace usb {
+namespace gadget {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::sp;
+using ::android::base::GetProperty;
+using ::android::base::SetProperty;
+using ::android::base::unique_fd;
+using ::android::base::WriteStringToFile;
+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::hardware::google::pixel::usb::addAdb;
+using ::android::hardware::google::pixel::usb::addEpollFd;
+using ::android::hardware::google::pixel::usb::getVendorFunctions;
+using ::android::hardware::google::pixel::usb::kDebug;
+using ::android::hardware::google::pixel::usb::kDisconnectWaitUs;
+using ::android::hardware::google::pixel::usb::linkFunction;
+using ::android::hardware::google::pixel::usb::MonitorFfs;
+using ::android::hardware::google::pixel::usb::resetGadget;
+using ::android::hardware::google::pixel::usb::setVidPid;
+using ::android::hardware::google::pixel::usb::unlinkFunctions;
+using ::std::string;
+
+constexpr char kGadgetName[] = "a600000.dwc3";
+static MonitorFfs monitorFfs(kGadgetName);
+
+struct UsbGadget : public IUsbGadget {
+    UsbGadget();
+
+    // Makes sure that only one request is processed at a time.
+    std::mutex mLockSetCurrentFunction;
+    uint64_t mCurrentUsbFunctions;
+    bool mCurrentUsbFunctionsApplied;
+
+    Return<void> setCurrentUsbFunctions(uint64_t functions, const sp<IUsbGadgetCallback> &callback,
+                                        uint64_t timeout) override;
+
+    Return<void> getCurrentUsbFunctions(const sp<IUsbGadgetCallback> &callback) override;
+
+  private:
+    Status tearDownGadget();
+    Status setupFunctions(uint64_t functions, const sp<IUsbGadgetCallback> &callback,
+                          uint64_t timeout);
+};
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace gadget
+}  // namespace usb
+}  // namespace hardware
+}  // namespace android
+
+#endif  // ANDROID_HARDWARE_USB_V1_2_USBGADGET_H
diff --git a/usb/android.hardware.usb@1.2-service.redfin.rc b/usb/android.hardware.usb@1.2-service.redfin.rc
new file mode 100644
index 0000000..d9c4946
--- /dev/null
+++ b/usb/android.hardware.usb@1.2-service.redfin.rc
@@ -0,0 +1,12 @@
+service vendor.usb-hal-1-2 /vendor/bin/hw/android.hardware.usb@1.2-service.redfin
+    class hal
+    user root
+    group root system shell mtp
+
+on boot
+    chown root system /sys/class/typec/port0/power_role
+    chown root system /sys/class/typec/port0/data_role
+    chown root system /sys/class/typec/port0/port_type
+    chmod 664 /sys/class/typec/port0/power_role
+    chmod 664 /sys/class/typec/port0/data_role
+    chmod 664 /sys/class/typec/port0/port_type
diff --git a/usb/service.cpp b/usb/service.cpp
new file mode 100644
index 0000000..c6768fe
--- /dev/null
+++ b/usb/service.cpp
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2018 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.
+ */
+
+#define LOG_TAG "android.hardware.usb@1.2-service.redfin"
+
+#include <hidl/HidlTransportSupport.h>
+#include "Usb.h"
+#include "UsbGadget.h"
+
+using android::sp;
+
+// libhwbinder:
+using android::hardware::configureRpcThreadpool;
+using android::hardware::joinRpcThreadpool;
+
+// Generated HIDL files
+using android::hardware::usb::gadget::V1_0::IUsbGadget;
+using android::hardware::usb::gadget::V1_0::implementation::UsbGadget;
+using android::hardware::usb::V1_2::IUsb;
+using android::hardware::usb::V1_2::implementation::Usb;
+
+using android::OK;
+using android::status_t;
+
+int main() {
+    android::sp<IUsb> service = new Usb();
+    android::sp<IUsbGadget> service2 = new UsbGadget();
+
+    configureRpcThreadpool(2, true /*callerWillJoin*/);
+    status_t status = service->registerAsService();
+
+    if (status != OK) {
+        ALOGE("Cannot register USB HAL service");
+        return 1;
+    }
+
+    status = service2->registerAsService();
+
+    if (status != OK) {
+        ALOGE("Cannot register USB Gadget HAL service");
+        return 1;
+    }
+
+    ALOGI("USB HAL Ready.");
+    joinRpcThreadpool();
+    // Under noraml cases, execution will not reach this line.
+    ALOGI("USB HAL failed to join thread pool.");
+    return 1;
+}