Evolution-x-devices/device_xiaomi_rosemary
2
0
Fork 0
mirror of https://github.com/Evolution-X-Devices/device_xiaomi_rosemary synced 2026-01-27 13:35:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

rosemary: usb_gadget: Adapt implementation for rosemary

Browse Source 
Change-Id: Id63c894d82bbc2d89246d35537ec1b19f3319746
Signed-off-by: bengris32 <bengris32@protonmail.ch>
This commit is contained in:
bengris32
2024-02-14 19:23:15 +00:00
parent 9bd655dafe
commit 8011d0ff19
5 changed files with 80 additions and 322 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
usb_gadget/Android.bp
View File

@@ -14,7 +14,7 @@
// limitations under the License.
cc_binary {
name: "android.hardware.usb.gadget-service.gs101",
name: "android.hardware.usb.gadget-service.rosemary",
relative_install_path: "hw",
init_rc: ["android.hardware.usb.gadget-service.rc"],
vintf_fragments: [

350
usb_gadget/UsbGadget.cpp
View File

@@ -37,91 +37,20 @@ namespace usb {
namespace gadget {
string enabledPath;
constexpr char kHsi2cPath[] = "/sys/devices/platform/10d50000.hsi2c";
constexpr char kI2CPath[] = "/sys/devices/platform/10d50000.hsi2c/i2c-";
constexpr char kAccessoryLimitCurrent[] = "i2c-max77759tcpc/usb_limit_accessory_current";
constexpr char kAccessoryLimitCurrentEnable[] = "i2c-max77759tcpc/usb_limit_accessory_enable";
constexpr char kUpdateSdpEnumTimeout[] = "i2c-max77759tcpc/update_sdp_enum_timeout";
using ::android::base::GetBoolProperty;
using ::android::hardware::google::pixel::usb::kUvcEnabled;
Status getI2cBusHelper(string *name) {
DIR *dp;
dp = opendir(kHsi2cPath);
if (dp != NULL) {
struct dirent *ep;
while ((ep = readdir(dp))) {
if (ep->d_type == DT_DIR) {
if (string::npos != string(ep->d_name).find("i2c-")) {
std::strtok(ep->d_name, "-");
*name = std::strtok(NULL, "-");
}
}
}
closedir(dp);
return Status::SUCCESS;
}
ALOGE("Failed to open %s", kHsi2cPath);
return Status::ERROR;
}
UsbGadget::UsbGadget() : mGadgetIrqPath("") {
UsbGadget::UsbGadget() {
if (access(OS_DESC_PATH, R_OK) != 0) {
ALOGE("configfs setup not done yet");
abort();
}
}
Status UsbGadget::getUsbGadgetIrqPath() {
std::string irqs;
size_t read_pos = 0;
size_t found_pos = 0;
if (!ReadFileToString(kProcInterruptsPath, &irqs)) {
ALOGE("cannot read all interrupts");
return Status::ERROR;
}
while (true) {
found_pos = irqs.find_first_of("\n", read_pos);
if (found_pos == std::string::npos) {
ALOGI("the string of all interrupts is unexpected");
return Status::ERROR;
}
std::string single_irq = irqs.substr(read_pos, found_pos - read_pos);
if (single_irq.find("dwc3", 0) != std::string::npos) {
unsigned int dwc3_irq_number;
size_t dwc3_pos = single_irq.find_first_of(":");
if (!ParseUint(single_irq.substr(0, dwc3_pos), &dwc3_irq_number)) {
ALOGI("unknown IRQ strings");
return Status::ERROR;
}
mGadgetIrqPath = kProcIrqPath + single_irq.substr(0, dwc3_pos) + kSmpAffinityList;
break;
}
if (found_pos == irqs.npos) {
ALOGI("USB gadget doesn't start");
return Status::ERROR;
}
read_pos = found_pos + 1;
}
return Status::SUCCESS;
}
void currentFunctionsAppliedCallback(bool functionsApplied, void *payload) {
UsbGadget *gadget = (UsbGadget *)payload;
gadget->mCurrentUsbFunctionsApplied = functionsApplied;
gadget->updateSdpEnumTimeout();
}
ScopedAStatus UsbGadget::getCurrentUsbFunctions(const shared_ptr<IUsbGadgetCallback> &callback,
@@ -186,178 +115,126 @@ Status UsbGadget::tearDownGadget() {
static Status validateAndSetVidPid(int64_t functions) {
Status ret;
std::string vendorFunctions = getVendorFunctions();
const char *vid, *pid;
std::string saving;
switch (functions) {
case GadgetFunction::MTP:
if (!(vendorFunctions == "user" || vendorFunctions == "")) {
ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
ret = Status::CONFIGURATION_NOT_SUPPORTED;
} else {
ret = Status(setVidPid("0x18d1", "0x4ee1"));
}
vid = "0x2717";
pid = "0xFF40";
saving = "2";
break;
case GadgetFunction::ADB |
GadgetFunction::MTP:
if (!(vendorFunctions == "user" || vendorFunctions == "")) {
ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
ret = Status::CONFIGURATION_NOT_SUPPORTED;
} else {
ret = Status(setVidPid("0x18d1", "0x4ee2"));
}
vid = "0x2717";
pid = "0xFF48";
break;
case GadgetFunction::RNDIS:
case GadgetFunction::RNDIS |
GadgetFunction::NCM:
if (!(vendorFunctions == "user" || vendorFunctions == "")) {
ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
ret = Status::CONFIGURATION_NOT_SUPPORTED;
} else {
ret = Status(setVidPid("0x18d1", "0x4ee3"));
}
vid = "0x2717";
pid = "0xFF80";
break;
case GadgetFunction::ADB |
GadgetFunction::RNDIS:
case GadgetFunction::ADB |
GadgetFunction::RNDIS |
GadgetFunction::NCM:
if (vendorFunctions == "dm") {
ret = Status(setVidPid("0x04e8", "0x6862"));
} else {
if (!(vendorFunctions == "user" || vendorFunctions == "")) {
ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
ret = Status::CONFIGURATION_NOT_SUPPORTED;
} else {
ret = Status(setVidPid("0x18d1", "0x4ee4"));
}
}
vid = "0x2717";
pid = "0xFF88";
break;
case GadgetFunction::PTP:
if (!(vendorFunctions == "user" || vendorFunctions == "")) {
ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
ret = Status::CONFIGURATION_NOT_SUPPORTED;
} else {
ret = Status(setVidPid("0x18d1", "0x4ee5"));
}
vid = "0x2717";
pid = "0xFF10";
saving = "2";
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 = Status(setVidPid("0x18d1", "0x4ee6"));
}
vid = "0x2717";
pid = "0xFF18";
break;
case GadgetFunction::ADB:
if (vendorFunctions == "dm") {
ret = Status(setVidPid("0x04e8", "0x6862"));
} else if (vendorFunctions == "etr_miu") {
ret = Status(setVidPid("0x18d1", "0x4ee2"));
} else if (vendorFunctions == "uwb_acm"){
ret = Status(setVidPid("0x18d1", "0x4ee2"));
} else {
if (!(vendorFunctions == "user" || vendorFunctions == "")) {
ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
ret = Status::CONFIGURATION_NOT_SUPPORTED;
} else {
ret = Status(setVidPid("0x18d1", "0x4ee7"));
}
}
vid = "0x2717";
pid = "0xFF08";
break;
case GadgetFunction::MIDI:
if (!(vendorFunctions == "user" || vendorFunctions == "")) {
ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
ret = Status::CONFIGURATION_NOT_SUPPORTED;
} else {
ret = Status(setVidPid("0x18d1", "0x4ee8"));
}
vid = "0x2717";
pid = "0x2046";
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 = Status(setVidPid("0x18d1", "0x4ee9"));
}
vid = "0x2717";
pid = "0x2048";
break;
case GadgetFunction::ACCESSORY:
if (!(vendorFunctions == "user" || vendorFunctions == ""))
ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
ret = Status(setVidPid("0x18d1", "0x2d00"));
vid = "0x18d1";
pid = "0x2d00";
break;
case GadgetFunction::ADB |
GadgetFunction::ACCESSORY:
if (!(vendorFunctions == "user" || vendorFunctions == ""))
ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
ret = Status(setVidPid("0x18d1", "0x2d01"));
vid = "0x18d1";
pid = "0x2d01";
break;
case GadgetFunction::AUDIO_SOURCE:
if (!(vendorFunctions == "user" || vendorFunctions == ""))
ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
ret = Status(setVidPid("0x18d1", "0x2d02"));
vid = "0x18d1";
pid = "0x2d02";
break;
case GadgetFunction::ADB |
GadgetFunction::AUDIO_SOURCE:
if (!(vendorFunctions == "user" || vendorFunctions == ""))
ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
ret = Status(setVidPid("0x18d1", "0x2d03"));
vid = "0x18d1";
pid = "0x2d03";
break;
case GadgetFunction::ACCESSORY |
GadgetFunction::AUDIO_SOURCE:
if (!(vendorFunctions == "user" || vendorFunctions == ""))
ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
ret = Status(setVidPid("0x18d1", "0x2d04"));
vid = "0x18d1";
pid = "0x2d04";
break;
case GadgetFunction::ADB |
GadgetFunction::ACCESSORY |
GadgetFunction::AUDIO_SOURCE:
if (!(vendorFunctions == "user" || vendorFunctions == ""))
ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
ret = Status(setVidPid("0x18d1", "0x2d05"));
vid = "0x18d1";
pid = "0x2d05";
break;
case GadgetFunction::NCM:
if (!(vendorFunctions == "user" || vendorFunctions == ""))
ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
ret = Status(setVidPid("0x18d1", "0x4eeb"));
vid = "0x2717";
pid = "0x2067";
break;
case GadgetFunction::ADB |
GadgetFunction::NCM:
if (vendorFunctions == "dm") {
ret = Status(setVidPid("0x04e8", "0x6862"));
} else {
if (!(vendorFunctions == "user" || vendorFunctions == ""))
ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
ret = Status(setVidPid("0x18d1", "0x4eec"));
}
vid = "0x2717";
pid = "0x206A";
break;
/*
* There are no known MediaTek devices that implement the
* device as webcam feature, so for the following functions
* we use Google's vid/pid.
* =======================================================
* TODO: 4.14's UVC function is not compatible with AOSP's
* device as webcam service.
* =======================================================
case GadgetFunction::UVC:
if (!(vendorFunctions == "user" || vendorFunctions == "")) {
ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
ret = Status::CONFIGURATION_NOT_SUPPORTED;
} else if (!GetBoolProperty(kUvcEnabled, false)) {
ALOGE("UVC function not enabled by config");
ret = Status::CONFIGURATION_NOT_SUPPORTED;
} else {
ret = Status(setVidPid("0x18d1", "0x4eed"));
}
vid = "0x18d1";
pid = "0x4eed";
break;
case GadgetFunction::ADB | GadgetFunction::UVC:
if (!(vendorFunctions == "user" || vendorFunctions == "")) {
ALOGE("Invalid vendorFunctions set: %s", vendorFunctions.c_str());
ret = Status::CONFIGURATION_NOT_SUPPORTED;
} else if (!GetBoolProperty(kUvcEnabled, false)) {
ALOGE("UVC function not enabled by config");
ret = Status::CONFIGURATION_NOT_SUPPORTED;
} else {
ret = Status(setVidPid("0x18d1", "0x4eee"));
}
vid = "0x18d1";
pid = "0x4eee";
break;
*/
default:
ALOGE("Combination not supported");
ret = Status::CONFIGURATION_NOT_SUPPORTED;
goto error;
}
ret = Status(setVidPid(vid, pid));
if (ret != Status::SUCCESS) {
ALOGE("Failed to update vid/pid");
goto error;
}
if (!saving.empty()) {
if (!WriteStringToFile(saving, SAVING_PATH)) {
ALOGE("Failed to update saving state");
ret = Status::ERROR;
}
}
error:
return ret;
}
@@ -388,22 +265,6 @@ ScopedAStatus UsbGadget::reset(const shared_ptr<IUsbGadgetCallback> &callback,
return ScopedAStatus::ok();
}
void UsbGadget::updateSdpEnumTimeout() {
string i2c_node, update_sdp_enum_timeout_path;
Status status = getI2cBusHelper(&i2c_node);
if (status != Status::SUCCESS) {
ALOGE("%s: Unable to locate i2c bus node", __func__);
}
update_sdp_enum_timeout_path = kI2CPath + i2c_node + "/" + kUpdateSdpEnumTimeout;
if (!WriteStringToFile("1", update_sdp_enum_timeout_path)) {
ALOGE("%s: Unable to write to %s.", __func__, update_sdp_enum_timeout_path.c_str());
} else {
ALOGI("%s: Updated SDP enumeration timeout value.", __func__);
}
}
Status UsbGadget::setupFunctions(long functions,
const shared_ptr<IUsbGadgetCallback> &callback, uint64_t timeout,
int64_t in_transactionId) {
@@ -414,31 +275,6 @@ Status UsbGadget::setupFunctions(long functions,
Status::SUCCESS)
return Status::ERROR;
std::string vendorFunctions = getVendorFunctions();
if (vendorFunctions == "dm") {
ALOGI("enable usbradio debug functions");
if ((functions & GadgetFunction::RNDIS) != 0) {
if (linkFunction("acm.gs6", i++))
return Status::ERROR;
if (linkFunction("dm.gs7", i++))
return Status::ERROR;
} else {
if (linkFunction("dm.gs7", i++))
return Status::ERROR;
if (linkFunction("acm.gs6", i++))
return Status::ERROR;
}
} else if (vendorFunctions == "etr_miu") {
ALOGI("enable etr_miu functions");
if (linkFunction("etr_miu.gs11", i++))
return Status::ERROR;
} else if (vendorFunctions == "uwb_acm") {
ALOGI("enable uwb acm function");
if (linkFunction("acm.uwb0", i++))
return Status::ERROR;
}
if ((functions & GadgetFunction::ADB) != 0) {
ffsEnabled = true;
if (Status(addAdb(&monitorFfs, &i)) != Status::SUCCESS)
@@ -458,7 +294,6 @@ Status UsbGadget::setupFunctions(long functions,
mCurrentUsbFunctionsApplied = true;
if (callback)
callback->setCurrentUsbFunctionsCb(functions, Status::SUCCESS, in_transactionId);
updateSdpEnumTimeout();
return Status::SUCCESS;
}
@@ -492,19 +327,9 @@ ScopedAStatus UsbGadget::setCurrentUsbFunctions(long functions,
std::string current_usb_power_operation_mode, current_usb_type;
std::string usb_limit_sink_enable;
string accessoryCurrentLimitEnablePath, accessoryCurrentLimitPath, path;
mCurrentUsbFunctions = functions;
mCurrentUsbFunctionsApplied = false;
getI2cBusHelper(&path);
accessoryCurrentLimitPath = kI2CPath + path + "/" + kAccessoryLimitCurrent;
accessoryCurrentLimitEnablePath = kI2CPath + path + "/" + kAccessoryLimitCurrentEnable;
// Get the gadget IRQ number before tearDownGadget()
if (mGadgetIrqPath.empty())
getUsbGadgetIrqPath();
// Unlink the gadget and stop the monitor if running.
Status status = tearDownGadget();
if (status != Status::SUCCESS) {
@@ -517,10 +342,15 @@ ScopedAStatus UsbGadget::setCurrentUsbFunctions(long functions,
usleep(kDisconnectWaitUs);
if (functions == GadgetFunction::NONE) {
// Make sure we reset saving state if there are no functions enabled.
if (!WriteStringToFile("0", SAVING_PATH)) {
ALOGE("Failed to reset saving state");
status = Status::ERROR;
}
if (callback == NULL)
return ScopedAStatus::fromServiceSpecificErrorWithMessage(
-1, "callback == NULL");
ScopedAStatus ret = callback->setCurrentUsbFunctionsCb(functions, Status::SUCCESS, in_transactionId);
ScopedAStatus ret = callback->setCurrentUsbFunctionsCb(functions, status, in_transactionId);
if (!ret.isOk())
ALOGE("Error while calling setCurrentUsbFunctionsCb %s", ret.getDescription().c_str());
return ScopedAStatus::fromServiceSpecificErrorWithMessage(
@@ -538,40 +368,6 @@ ScopedAStatus UsbGadget::setCurrentUsbFunctions(long functions,
goto error;
}
if (functions & GadgetFunction::NCM) {
if (!mGadgetIrqPath.empty()) {
if (!WriteStringToFile(BIG_CORE, mGadgetIrqPath))
ALOGI("Cannot move gadget IRQ to big core, path:%s", mGadgetIrqPath.c_str());
}
} else {
if (!mGadgetIrqPath.empty()) {
if (!WriteStringToFile(MEDIUM_CORE, mGadgetIrqPath))
ALOGI("Cannot move gadget IRQ to medium core, path:%s", mGadgetIrqPath.c_str());
}
}
if (ReadFileToString(CURRENT_USB_TYPE_PATH, &current_usb_type))
current_usb_type = Trim(current_usb_type);
if (ReadFileToString(CURRENT_USB_POWER_OPERATION_MODE_PATH, &current_usb_power_operation_mode))
current_usb_power_operation_mode = Trim(current_usb_power_operation_mode);
if (functions & GadgetFunction::ACCESSORY &&
current_usb_type == "Unknown SDP [CDP] DCP" &&
(current_usb_power_operation_mode == "default" ||
current_usb_power_operation_mode == "1.5A")) {
if (!WriteStringToFile("1300000", accessoryCurrentLimitPath)) {
ALOGI("Write 1.3A to limit current fail");
} else {
if (!WriteStringToFile("1", accessoryCurrentLimitEnablePath)) {
ALOGI("Enable limit current fail");
}
}
} else {
if (!WriteStringToFile("0", accessoryCurrentLimitEnablePath))
ALOGI("unvote accessory limit current failed");
}
ALOGI("Usb Gadget setcurrent functions called successfully");
return ScopedAStatus::ok();

28
usb_gadget/UsbGadget.h
View File

@@ -19,7 +19,6 @@
#include <android-base/file.h>
#include <android-base/properties.h>
#include <android-base/unique_fd.h>
#include <android-base/parseint.h>
#include <android-base/strings.h>
#include <aidl/android/hardware/usb/gadget/BnUsbGadget.h>
#include <aidl/android/hardware/usb/gadget/BnUsbGadgetCallback.h>
@@ -50,14 +49,12 @@ using ::aidl::android::hardware::usb::gadget::Status;
using ::aidl::android::hardware::usb::gadget::UsbSpeed;
using ::android::base::GetProperty;
using ::android::base::SetProperty;
using ::android::base::ParseUint;
using ::android::base::unique_fd;
using ::android::base::ReadFileToString;
using ::android::base::Trim;
using ::android::base::WriteStringToFile;
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;
@@ -69,33 +66,21 @@ using ::ndk::ScopedAStatus;
using ::std::shared_ptr;
using ::std::string;
constexpr char kGadgetName[] = "11110000.dwc3";
constexpr char kProcInterruptsPath[] = "/proc/interrupts";
constexpr char kProcIrqPath[] = "/proc/irq/";
constexpr char kSmpAffinityList[] = "/smp_affinity_list";
constexpr char kGadgetName[] = "musb-hdrc";
#ifndef UDC_PATH
#define UDC_PATH "/sys/class/udc/11110000.dwc3/"
#define UDC_PATH "/sys/class/udc/musb-hdrc/"
#endif
static MonitorFfs monitorFfs(kGadgetName);
#define DEVICE "device/"
#define SPEED_PATH UDC_PATH "current_speed"
#define BIG_CORE "6"
#define MEDIUM_CORE "4"
#define POWER_SUPPLY_PATH "/sys/class/power_supply/usb/"
#define USB_PORT0_PATH "/sys/class/typec/port0/"
#define CURRENT_MAX_PATH POWER_SUPPLY_PATH "current_max"
#define CURRENT_USB_TYPE_PATH POWER_SUPPLY_PATH "usb_type"
#define CURRENT_USB_POWER_OPERATION_MODE_PATH USB_PORT0_PATH "power_operation_mode"
#define SAVING_PATH UDC_PATH DEVICE "saving"
struct UsbGadget : public BnUsbGadget {
UsbGadget();
// Makes sure that only one request is processed at a time.
std::mutex mLockSetCurrentFunction;
std::string mGadgetIrqPath;
long mCurrentUsbFunctions;
bool mCurrentUsbFunctionsApplied;
UsbSpeed mUsbSpeed;
@@ -115,13 +100,8 @@ struct UsbGadget : public BnUsbGadget {
ScopedAStatus setVidPid(const char *vid,const char *pid);
// Indicates to the kernel that the gadget service is ready and the kernel can
// set SDP timeout to a lower value.
void updateSdpEnumTimeout();
private:
Status tearDownGadget();
Status getUsbGadgetIrqPath();
Status setupFunctions(long functions, const shared_ptr<IUsbGadgetCallback> &callback,
uint64_t timeout, int64_t in_transactionId);
};

20
usb_gadget/android.hardware.usb.gadget-service.rc
View File

@@ -1,22 +1,4 @@
service vendor.usb-gadget-hal /vendor/bin/hw/android.hardware.usb.gadget-service.gs101
service vendor.usb-gadget-hal /vendor/bin/hw/android.hardware.usb.gadget-service.rosemary
class hal
user system
group system shell mtp
on post-fs
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
chown root system /sys/devices/platform/10d50000.hsi2c/i2c-5/i2c-max77759tcpc/contaminant_detection
chown root system /sys/devices/platform/10d50000.hsi2c/i2c-6/i2c-max77759tcpc/contaminant_detection
chown root system /sys/devices/platform/10d50000.hsi2c/i2c-7/i2c-max77759tcpc/contaminant_detection
chown root system /sys/devices/platform/10d50000.hsi2c/i2c-8/i2c-max77759tcpc/contaminant_detection
chown root system /sys/devices/platform/11110000.usb/dwc3_exynos_otg_b_sess
chown root system /sys/devices/platform/11110000.usb/dwc3_exynos_otg_id
chown root system /sys/devices/platform/11110000.usb/usb_data_enabled
chmod 664 /sys/class/typec/port0/power_role
chmod 664 /sys/class/typec/port0/data_role
chmod 664 /sys/class/typec/port0/port_type
chmod 664 /sys/devices/platform/11110000.usb/dwc3_exynos_otg_b_sess
chmod 664 /sys/devices/platform/11110000.usb/dwc3_exynos_otg_id
chmod 664 /sys/devices/platform/11110000.usb/usb_data_enabled

2
usb_gadget/service_gadget.cpp
View File

@@ -14,7 +14,7 @@
* limitations under the License.
*/
#define LOG_TAG "android.hardware.usb.gadget-service.gs101"
#define LOG_TAG "android.hardware.usb.gadget-service.rosemary"
#include <android-base/logging.h>
#include <android/binder_manager.h>