Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 9bfb4352 authored by Howard Yen's avatar Howard Yen
Browse files

Add USB Gadget Hal v1.1 default implementation 

Bug: 147645728
Test: Build pass and service running
Change-Id: I5648b569dc470deba14a4fc8a0c841e76a0f1b86
parent 78ca380c

usb/gadget/1.1/default/Android.bp

0 → 100644
+39 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2020 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.gadget@1.1-service",

    defaults: ["hidl_defaults"],

    relative_install_path: "hw",

    init_rc: ["android.hardware.usb.gadget@1.1-service.rc"],

    vintf_fragments: ["android.hardware.usb.gadget@1.1-service.xml"],

    vendor: true,

    srcs: [

        "service.cpp",

        "UsbGadget.cpp",

    ],

    shared_libs: [

        "android.hardware.usb.gadget@1.0",

        "android.hardware.usb.gadget@1.1",

        "libbase",

        "libcutils",

        "libhardware",

        "libhidlbase",

        "liblog",

        "libutils",

    ],

    static_libs: ["libusbconfigfs"],

}

usb/gadget/1.1/default/UsbGadget.cpp

0 → 100644
+229 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2020 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.1-service"



#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_1 {

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() != V1_0::Status::SUCCESS) return V1_0::Status::ERROR;



    if (monitorFfs.isMonitorRunning()) {

        monitorFfs.reset();

    } else {

        ALOGI("mMonitor not running");

    }

    return V1_0::Status::SUCCESS;

}



Return<Status> UsbGadget::reset() {

    if (!WriteStringToFile("none", PULLUP_PATH)) {

        ALOGI("Gadget cannot be pulled down");

        return Status::ERROR;

    }



    return Status::SUCCESS;

}



static V1_0::Status validateAndSetVidPid(uint64_t functions) {

    V1_0::Status ret = V1_0::Status::SUCCESS;



    switch (functions) {

        case static_cast<uint64_t>(V1_0::GadgetFunction::MTP):

            ret = setVidPid("0x18d1", "0x4ee1");

            break;

        case V1_0::GadgetFunction::ADB | V1_0::GadgetFunction::MTP:

            ret = setVidPid("0x18d1", "0x4ee2");

            break;

        case static_cast<uint64_t>(V1_0::GadgetFunction::RNDIS):

            ret = setVidPid("0x18d1", "0x4ee3");

            break;

        case V1_0::GadgetFunction::ADB | V1_0::GadgetFunction::RNDIS:

            ret = setVidPid("0x18d1", "0x4ee4");

            break;

        case static_cast<uint64_t>(V1_0::GadgetFunction::PTP):

            ret = setVidPid("0x18d1", "0x4ee5");

            break;

        case V1_0::GadgetFunction::ADB | V1_0::GadgetFunction::PTP:

            ret = setVidPid("0x18d1", "0x4ee6");

            break;

        case static_cast<uint64_t>(V1_0::GadgetFunction::ADB):

            ret = setVidPid("0x18d1", "0x4ee7");

            break;

        case static_cast<uint64_t>(V1_0::GadgetFunction::MIDI):

            ret = setVidPid("0x18d1", "0x4ee8");

            break;

        case V1_0::GadgetFunction::ADB | V1_0::GadgetFunction::MIDI:

            ret = setVidPid("0x18d1", "0x4ee9");

            break;

        case static_cast<uint64_t>(V1_0::GadgetFunction::ACCESSORY):

            ret = setVidPid("0x18d1", "0x2d00");

            break;

        case V1_0::GadgetFunction::ADB | V1_0::GadgetFunction::ACCESSORY:

            ret = setVidPid("0x18d1", "0x2d01");

            break;

        case static_cast<uint64_t>(V1_0::GadgetFunction::AUDIO_SOURCE):

            ret = setVidPid("0x18d1", "0x2d02");

            break;

        case V1_0::GadgetFunction::ADB | V1_0::GadgetFunction::AUDIO_SOURCE:

            ret = setVidPid("0x18d1", "0x2d03");

            break;

        case V1_0::GadgetFunction::ACCESSORY | V1_0::GadgetFunction::AUDIO_SOURCE:

            ret = setVidPid("0x18d1", "0x2d04");

            break;

        case V1_0::GadgetFunction::ADB | V1_0::GadgetFunction::ACCESSORY |

                V1_0::GadgetFunction::AUDIO_SOURCE:

            ret = setVidPid("0x18d1", "0x2d05");

            break;

        default:

            ALOGE("Combination not supported");

            ret = V1_0::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) !=

        V1_0::Status::SUCCESS)

        return V1_0::Status::ERROR;



    if ((functions & V1_0::GadgetFunction::ADB) != 0) {

        ffsEnabled = true;

        if (addAdb(&monitorFfs, &i) != V1_0::Status::SUCCESS) return V1_0::Status::ERROR;

    }



    // Pull up the gadget right away when there are no ffs functions.

    if (!ffsEnabled) {

        if (!WriteStringToFile(kGadgetName, PULLUP_PATH)) return V1_0::Status::ERROR;

        mCurrentUsbFunctionsApplied = true;

        if (callback) callback->setCurrentUsbFunctionsCb(functions, V1_0::Status::SUCCESS);

        return V1_0::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 ? V1_0::Status::SUCCESS : V1_0::Status::ERROR);

        if (!ret.isOk()) ALOGE("setCurrentUsbFunctionsCb error %s", ret.description().c_str());

    }



    return V1_0::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 != V1_0::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>(V1_0::GadgetFunction::NONE)) {

        if (callback == NULL) return Void();

        Return<void> ret = callback->setCurrentUsbFunctionsCb(functions, V1_0::Status::SUCCESS);

        if (!ret.isOk())

            ALOGE("Error while calling setCurrentUsbFunctionsCb %s", ret.description().c_str());

        return Void();

    }



    status = validateAndSetVidPid(functions);



    if (status != V1_0::Status::SUCCESS) {

        goto error;

    }



    status = setupFunctions(functions, callback, timeout);

    if (status != V1_0::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_1

}  // namespace gadget

}  // namespace usb

}  // namespace hardware

}  // namespace android

usb/gadget/1.1/default/UsbGadget.h

0 → 100644
+98 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2020 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_1_USBGADGET_H

#define ANDROID_HARDWARE_USB_GADGET_V1_1_USBGADGET_H



#include <UsbGadgetCommon.h>

#include <android-base/file.h>

#include <android-base/properties.h>

#include <android-base/unique_fd.h>

#include <android/hardware/usb/gadget/1.1/IUsbGadget.h>

#include <hidl/MQDescriptor.h>

#include <hidl/Status.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_1 {

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::usb::gadget::addAdb;

using ::android::hardware::usb::gadget::addEpollFd;

using ::android::hardware::usb::gadget::getVendorFunctions;

using ::android::hardware::usb::gadget::kDebug;

using ::android::hardware::usb::gadget::kDisconnectWaitUs;

using ::android::hardware::usb::gadget::linkFunction;

using ::android::hardware::usb::gadget::MonitorFfs;

using ::android::hardware::usb::gadget::resetGadget;

using ::android::hardware::usb::gadget::setVidPid;

using ::android::hardware::usb::gadget::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<V1_0::IUsbGadgetCallback>& callback,

                                        uint64_t timeout) override;



    Return<void> getCurrentUsbFunctions(const sp<V1_0::IUsbGadgetCallback>& callback) override;



    Return<Status> reset() override;



  private:

    V1_0::Status tearDownGadget();

    V1_0::Status setupFunctions(uint64_t functions, const sp<V1_0::IUsbGadgetCallback>& callback,

                                uint64_t timeout);

};



}  // namespace implementation

}  // namespace V1_1

}  // namespace gadget

}  // namespace usb

}  // namespace hardware

}  // namespace android



#endif  // ANDROID_HARDWARE_USB_V1_1_USBGADGET_H

usb/gadget/1.1/default/android.hardware.usb.gadget@1.1-service.rc

0 → 100644
+6 −0
Original line number Diff line number Diff line 
service vendor.usb-gadget-hal-1-1 /vendor/bin/hw/android.hardware.usb.gadget@1.1-service

    interface android.hardware.usb.gadget@1.0::IUsbGadget default

    interface android.hardware.usb.gadget@1.1::IUsbGadget default

    class hal

    user root

    group root shell mtp

usb/gadget/1.1/default/android.hardware.usb.gadget@1.1-service.xml

0 → 100644
+12 −0
Original line number Diff line number Diff line 
<manifest version="1.0" type="device">

    <hal format="hidl">

        <name>android.hardware.usb.gadget</name>

        <transport>hwbinder</transport>

        <version>1.1</version>

        <interface>

            <name>IUsbGadget</name>

            <instance>default</instance>

        </interface>

    </hal>

</manifest>