usb/1.0/default/Usb.cpp - LeafOS-Project/android_hardware_interfaces - Gitiles

 /*
  * 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 <assert.h>
 #include <dirent.h>
 #include <iostream>
 #include <fstream>
 #include <pthread.h>
 #include <stdio.h>
 #include <sys/types.h>
 #include <unistd.h>

 #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_0 {
 namespace implementation {

 // Set by the signal handler to destroy the thread
 volatile bool destroyThread;

 int32_t readFile(std::string filename, std::string& contents) {
     std::ifstream file(filename);

     if (file.is_open()) {
         getline(file, contents);
         file.close();
         return 0;
     }
     return -1;
 }

 std::string appendRoleNodeHelper(const std::string portName, PortRoleType type) {
     std::string node("/sys/class/dual_role_usb/" + portName);

     switch(type) {
         case PortRoleType::DATA_ROLE:
             return node + "/data_role";
         case PortRoleType::POWER_ROLE:
             return node + "/power_role";
         default:
             return node + "/mode";
     }
 }

 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::UFP))
             return "ufp";
         if (role.role == static_cast<uint32_t> (PortMode::DFP))
             return "dfp";
     }
     return "none";
 }

 Return<void> Usb::switchRole(const hidl_string& portName,
         const PortRole& newRole) {
     std::string filename = appendRoleNodeHelper(std::string(portName.c_str()),
         newRole.type);
     std::ofstream file(filename);
     std::string written;

     ALOGI("filename write: %s role:%d", filename.c_str(), newRole.role);

     if (file.is_open()) {
         file << convertRoletoString(newRole).c_str();
         file.close();
         if (!readFile(filename, written)) {
             ALOGI("written: %s", written.c_str());
             if (written == convertRoletoString(newRole)) {
                 ALOGI("Role switch successfull");
                 Return<void> ret =
                     mCallback->notifyRoleSwitchStatus(portName, newRole,
                     Status::SUCCESS);
                 if (!ret.isOk())
                     ALOGE("RoleSwitchStatus error %s",
                         ret.description().c_str());
             }
         }
     }

     Return<void> ret = mCallback->notifyRoleSwitchStatus(portName, newRole, Status::ERROR);
     if (!ret.isOk())
         ALOGE("RoleSwitchStatus error %s", ret.description().c_str());

     return Void();
 }

 Status getCurrentRoleHelper(std::string portName,
         PortRoleType type, uint32_t &currentRole)  {
     std::string filename;
     std::string roleName;

     if (type == PortRoleType::POWER_ROLE) {
         filename = "/sys/class/dual_role_usb/" +
             portName + "/power_role";
         currentRole = static_cast<uint32_t>(PortPowerRole::NONE);
     } else if (type == PortRoleType::DATA_ROLE) {
         filename = "/sys/class/dual_role_usb/" +
             portName + "/data_role";
         currentRole = static_cast<uint32_t> (PortDataRole::NONE);
     } else if (type == PortRoleType::MODE) {
         filename = "/sys/class/dual_role_usb/" +
             portName + "/mode";
         currentRole = static_cast<uint32_t> (PortMode::NONE);
     }

     if (readFile(filename, roleName)) {
         ALOGE("getCurrentRole: Failed to open filesystem node");
         return Status::ERROR;
     }

     if (roleName == "dfp")
         currentRole = static_cast<uint32_t> (PortMode::DFP);
     else if (roleName == "ufp")
         currentRole = static_cast<uint32_t> (PortMode::UFP);
     else 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")
         currentRole = static_cast<uint32_t> (PortDataRole::HOST);
     else if (roleName == "device")
         currentRole = static_cast<uint32_t> (PortDataRole::DEVICE);
     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::vector<std::string>& names) {
     DIR *dp;

     dp = opendir("/sys/class/dual_role_usb");
     if (dp != NULL)
     {
 rescan:
         int32_t ports = 0;
         int32_t current = 0;
         struct dirent *ep;

         while ((ep = readdir (dp))) {
             if (ep->d_type == DT_LNK) {
                 ports++;
             }
         }

         if (ports == 0) {
             closedir(dp);
             return Status::SUCCESS;
         }

         names.resize(ports);
         rewinddir(dp);

         while ((ep = readdir (dp))) {
             if (ep->d_type == DT_LNK) {
                 /* Check to see if new ports were added since the first pass. */
                 if (current >= ports) {
                     rewinddir(dp);
                     goto rescan;
                 }
                 names[current++] = ep->d_name;
             }
         }

         closedir (dp);
         return Status::SUCCESS;
     }

     ALOGE("Failed to open /sys/class/dual_role_usb");
     return Status::ERROR;
 }

 bool canSwitchRoleHelper(const std::string portName, PortRoleType type)  {
     std::string filename = appendRoleNodeHelper(portName, type);
     std::ofstream file(filename);

     if (file.is_open()) {
         file.close();
         return true;
     }
     return false;
 }

 Status getPortModeHelper(const std::string portName, PortMode& portMode)  {
     std::string filename = "/sys/class/dual_role_usb/" +
     std::string(portName.c_str()) + "/supported_modes";
     std::string modes;

     if (readFile(filename, modes)) {
         ALOGE("getSupportedRoles: Failed to open filesystem node");
         return Status::ERROR;
     }

     if (modes == "ufp dfp")
         portMode = PortMode::DRP;
     else  if (modes == "ufp")
         portMode = PortMode::UFP;
     else if  (modes == "dfp")
         portMode = PortMode::DFP;
     else
         return Status::UNRECOGNIZED_ROLE;

     return Status::SUCCESS;
 }

 Status getPortStatusHelper (hidl_vec<PortStatus>& currentPortStatus) {
     std::vector<std::string> names;
     Status result = getTypeCPortNamesHelper(names);

     if (result == Status::SUCCESS) {
         currentPortStatus.resize(names.size());
         for(std::vector<std::string>::size_type i = 0; i < names.size(); i++) {
             ALOGI("%s", names[i].c_str());
             currentPortStatus[i].portName = names[i];

             uint32_t currentRole;
             if (getCurrentRoleHelper(names[i], PortRoleType::POWER_ROLE,
                     currentRole) == Status::SUCCESS) {
                 currentPortStatus[i].currentPowerRole =
                 static_cast<PortPowerRole> (currentRole);
             } else {
                 ALOGE("Error while retreiving portNames");
                 goto done;
             }

             if (getCurrentRoleHelper(names[i],
                     PortRoleType::DATA_ROLE, currentRole) == Status::SUCCESS) {
                 currentPortStatus[i].currentDataRole =
                         static_cast<PortDataRole> (currentRole);
             } else {
                 ALOGE("Error while retreiving current port role");
                 goto done;
             }

             if (getCurrentRoleHelper(names[i], PortRoleType::MODE,
                     currentRole) == Status::SUCCESS) {
                 currentPortStatus[i].currentMode =
                     static_cast<PortMode> (currentRole);
             } else {
                 ALOGE("Error while retreiving current data role");
                 goto done;
             }

             currentPortStatus[i].canChangeMode =
                 canSwitchRoleHelper(names[i], PortRoleType::MODE);
             currentPortStatus[i].canChangeDataRole =
                 canSwitchRoleHelper(names[i], PortRoleType::DATA_ROLE);
             currentPortStatus[i].canChangePowerRole =
                 canSwitchRoleHelper(names[i], PortRoleType::POWER_ROLE);

             ALOGI("canChangeMode: %d canChagedata: %d canChangePower:%d",
                 currentPortStatus[i].canChangeMode,
                 currentPortStatus[i].canChangeDataRole,
                 currentPortStatus[i].canChangePowerRole);

             if (getPortModeHelper(names[i], currentPortStatus[i].supportedModes)
                   != Status::SUCCESS) {
                 ALOGE("Error while retrieving port modes");
                 goto done;
             }
         }
         return Status::SUCCESS;
     }
 done:
     return Status::ERROR;
 }

 Return<void> Usb::queryPortStatus() {
     hidl_vec<PortStatus> currentPortStatus;
     Status status;

     status = getPortStatusHelper(currentPortStatus);
     Return<void> ret = mCallback->notifyPortStatusChange(currentPortStatus,
        status);
     if (!ret.isOk())
         ALOGE("queryPortStatus error %s", ret.description().c_str());

     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 (!strcmp(cp, "SUBSYSTEM=dual_role_usb")) {
             ALOGE("uevent received %s", cp);
             if (payload->usb->mCallback != NULL) {
                 hidl_vec<PortStatus> currentPortStatus;
                 Status status = getPortStatusHelper(currentPortStatus);
                 Return<void> ret =
                     payload->usb->mCallback->notifyPortStatusChange(currentPortStatus, status);
                 if (!ret.isOk())
                     ALOGE("error %s", ret.description().c_str());
             }
             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<void> Usb::setCallback(const sp<IUsbCallback>& callback) {

     pthread_mutex_lock(&mLock);
     if ((mCallback == NULL && callback == NULL) ||
             (mCallback != NULL && callback != NULL)) {
         mCallback = callback;
         pthread_mutex_unlock(&mLock);
         return Void();
     }

     mCallback = callback;
     ALOGI("registering callback");

     if (mCallback == NULL) {
         if  (!pthread_kill(mPoll, SIGUSR1)) {
             pthread_join(mPoll, NULL);
             ALOGI("pthread destroyed");
         }
         pthread_mutex_unlock(&mLock);
         return Void();
     }

     destroyThread = false;
     signal(SIGUSR1, sighandler);

     if (pthread_create(&mPoll, NULL, work, this)) {
         ALOGE("pthread creation failed %d", errno);
         mCallback = NULL;
     }
     pthread_mutex_unlock(&mLock);
     return Void();
 }

 // Protects *usb assignment
 pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
 Usb *usb;

 Usb::Usb() {
     pthread_mutex_lock(&lock);
     // Make this a singleton class
     assert(usb == NULL);
     usb = this;
     pthread_mutex_unlock(&lock);
 }

 }  // namespace implementation
 }  // namespace V1_0
 }  // namespace usb
 }  // namespace hardware
 }  // namespace android
	/*
	* 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 <assert.h>
	#include <dirent.h>
	#include <iostream>
	#include <fstream>
	#include <pthread.h>
	#include <stdio.h>
	#include <sys/types.h>
	#include <unistd.h>

	#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_0 {
	namespace implementation {

	// Set by the signal handler to destroy the thread
	volatile bool destroyThread;

	int32_t readFile(std::string filename, std::string& contents) {
	std::ifstream file(filename);

	if (file.is_open()) {
	getline(file, contents);
	file.close();
	return 0;
	}
	return -1;
	}

	std::string appendRoleNodeHelper(const std::string portName, PortRoleType type) {
	std::string node("/sys/class/dual_role_usb/" + portName);

	switch(type) {
	case PortRoleType::DATA_ROLE:
	return node + "/data_role";
	case PortRoleType::POWER_ROLE:
	return node + "/power_role";
	default:
	return node + "/mode";
	}
	}

	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::UFP))
	return "ufp";
	if (role.role == static_cast<uint32_t> (PortMode::DFP))
	return "dfp";
	}
	return "none";
	}

	Return<void> Usb::switchRole(const hidl_string& portName,
	const PortRole& newRole) {
	std::string filename = appendRoleNodeHelper(std::string(portName.c_str()),
	newRole.type);
	std::ofstream file(filename);
	std::string written;

	ALOGI("filename write: %s role:%d", filename.c_str(), newRole.role);

	if (file.is_open()) {
	file << convertRoletoString(newRole).c_str();
	file.close();
	if (!readFile(filename, written)) {
	ALOGI("written: %s", written.c_str());
	if (written == convertRoletoString(newRole)) {
	ALOGI("Role switch successfull");
	Return<void> ret =
	mCallback->notifyRoleSwitchStatus(portName, newRole,
	Status::SUCCESS);
	if (!ret.isOk())
	ALOGE("RoleSwitchStatus error %s",
	ret.description().c_str());
	}
	}
	}

	Return<void> ret = mCallback->notifyRoleSwitchStatus(portName, newRole, Status::ERROR);
	if (!ret.isOk())
	ALOGE("RoleSwitchStatus error %s", ret.description().c_str());

	return Void();
	}

	Status getCurrentRoleHelper(std::string portName,
	PortRoleType type, uint32_t &currentRole) {
	std::string filename;
	std::string roleName;

	if (type == PortRoleType::POWER_ROLE) {
	filename = "/sys/class/dual_role_usb/" +
	portName + "/power_role";
	currentRole = static_cast<uint32_t>(PortPowerRole::NONE);
	} else if (type == PortRoleType::DATA_ROLE) {
	filename = "/sys/class/dual_role_usb/" +
	portName + "/data_role";
	currentRole = static_cast<uint32_t> (PortDataRole::NONE);
	} else if (type == PortRoleType::MODE) {
	filename = "/sys/class/dual_role_usb/" +
	portName + "/mode";
	currentRole = static_cast<uint32_t> (PortMode::NONE);
	}

	if (readFile(filename, roleName)) {
	ALOGE("getCurrentRole: Failed to open filesystem node");
	return Status::ERROR;
	}

	if (roleName == "dfp")
	currentRole = static_cast<uint32_t> (PortMode::DFP);
	else if (roleName == "ufp")
	currentRole = static_cast<uint32_t> (PortMode::UFP);
	else 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")
	currentRole = static_cast<uint32_t> (PortDataRole::HOST);
	else if (roleName == "device")
	currentRole = static_cast<uint32_t> (PortDataRole::DEVICE);
	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::vector<std::string>& names) {
	DIR *dp;

	dp = opendir("/sys/class/dual_role_usb");
	if (dp != NULL)
	{
	rescan:
	int32_t ports = 0;
	int32_t current = 0;
	struct dirent *ep;

	while ((ep = readdir (dp))) {
	if (ep->d_type == DT_LNK) {
	ports++;
	}
	}

	if (ports == 0) {
	closedir(dp);
	return Status::SUCCESS;
	}

	names.resize(ports);
	rewinddir(dp);

	while ((ep = readdir (dp))) {
	if (ep->d_type == DT_LNK) {
	/* Check to see if new ports were added since the first pass. */
	if (current >= ports) {
	rewinddir(dp);
	goto rescan;
	}
	names[current++] = ep->d_name;
	}
	}

	closedir (dp);
	return Status::SUCCESS;
	}

	ALOGE("Failed to open /sys/class/dual_role_usb");
	return Status::ERROR;
	}

	bool canSwitchRoleHelper(const std::string portName, PortRoleType type) {
	std::string filename = appendRoleNodeHelper(portName, type);
	std::ofstream file(filename);

	if (file.is_open()) {
	file.close();
	return true;
	}
	return false;
	}

	Status getPortModeHelper(const std::string portName, PortMode& portMode) {
	std::string filename = "/sys/class/dual_role_usb/" +
	std::string(portName.c_str()) + "/supported_modes";
	std::string modes;

	if (readFile(filename, modes)) {
	ALOGE("getSupportedRoles: Failed to open filesystem node");
	return Status::ERROR;
	}

	if (modes == "ufp dfp")
	portMode = PortMode::DRP;
	else if (modes == "ufp")
	portMode = PortMode::UFP;
	else if (modes == "dfp")
	portMode = PortMode::DFP;
	else
	return Status::UNRECOGNIZED_ROLE;

	return Status::SUCCESS;
	}

	Status getPortStatusHelper (hidl_vec<PortStatus>& currentPortStatus) {
	std::vector<std::string> names;
	Status result = getTypeCPortNamesHelper(names);

	if (result == Status::SUCCESS) {
	currentPortStatus.resize(names.size());
	for(std::vector<std::string>::size_type i = 0; i < names.size(); i++) {
	ALOGI("%s", names[i].c_str());
	currentPortStatus[i].portName = names[i];

	uint32_t currentRole;
	if (getCurrentRoleHelper(names[i], PortRoleType::POWER_ROLE,
	currentRole) == Status::SUCCESS) {
	currentPortStatus[i].currentPowerRole =
	static_cast<PortPowerRole> (currentRole);
	} else {
	ALOGE("Error while retreiving portNames");
	goto done;
	}

	if (getCurrentRoleHelper(names[i],
	PortRoleType::DATA_ROLE, currentRole) == Status::SUCCESS) {
	currentPortStatus[i].currentDataRole =
	static_cast<PortDataRole> (currentRole);
	} else {
	ALOGE("Error while retreiving current port role");
	goto done;
	}

	if (getCurrentRoleHelper(names[i], PortRoleType::MODE,
	currentRole) == Status::SUCCESS) {
	currentPortStatus[i].currentMode =
	static_cast<PortMode> (currentRole);
	} else {
	ALOGE("Error while retreiving current data role");
	goto done;
	}

	currentPortStatus[i].canChangeMode =
	canSwitchRoleHelper(names[i], PortRoleType::MODE);
	currentPortStatus[i].canChangeDataRole =
	canSwitchRoleHelper(names[i], PortRoleType::DATA_ROLE);
	currentPortStatus[i].canChangePowerRole =
	canSwitchRoleHelper(names[i], PortRoleType::POWER_ROLE);

	ALOGI("canChangeMode: %d canChagedata: %d canChangePower:%d",
	currentPortStatus[i].canChangeMode,
	currentPortStatus[i].canChangeDataRole,
	currentPortStatus[i].canChangePowerRole);

	if (getPortModeHelper(names[i], currentPortStatus[i].supportedModes)
	!= Status::SUCCESS) {
	ALOGE("Error while retrieving port modes");
	goto done;
	}
	}
	return Status::SUCCESS;
	}
	done:
	return Status::ERROR;
	}

	Return<void> Usb::queryPortStatus() {
	hidl_vec<PortStatus> currentPortStatus;
	Status status;

	status = getPortStatusHelper(currentPortStatus);
	Return<void> ret = mCallback->notifyPortStatusChange(currentPortStatus,
	status);
	if (!ret.isOk())
	ALOGE("queryPortStatus error %s", ret.description().c_str());

	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 (!strcmp(cp, "SUBSYSTEM=dual_role_usb")) {
	ALOGE("uevent received %s", cp);
	if (payload->usb->mCallback != NULL) {
	hidl_vec<PortStatus> currentPortStatus;
	Status status = getPortStatusHelper(currentPortStatus);
	Return<void> ret =
	payload->usb->mCallback->notifyPortStatusChange(currentPortStatus, status);
	if (!ret.isOk())
	ALOGE("error %s", ret.description().c_str());
	}
	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<void> Usb::setCallback(const sp<IUsbCallback>& callback) {

	pthread_mutex_lock(&mLock);
	if ((mCallback == NULL && callback == NULL) \|\|
	(mCallback != NULL && callback != NULL)) {
	mCallback = callback;
	pthread_mutex_unlock(&mLock);
	return Void();
	}

	mCallback = callback;
	ALOGI("registering callback");

	if (mCallback == NULL) {
	if (!pthread_kill(mPoll, SIGUSR1)) {
	pthread_join(mPoll, NULL);
	ALOGI("pthread destroyed");
	}
	pthread_mutex_unlock(&mLock);
	return Void();
	}

	destroyThread = false;
	signal(SIGUSR1, sighandler);

	if (pthread_create(&mPoll, NULL, work, this)) {
	ALOGE("pthread creation failed %d", errno);
	mCallback = NULL;
	}
	pthread_mutex_unlock(&mLock);
	return Void();
	}

	// Protects *usb assignment
	pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
	Usb *usb;

	Usb::Usb() {
	pthread_mutex_lock(&lock);
	// Make this a singleton class
	assert(usb == NULL);
	usb = this;
	pthread_mutex_unlock(&lock);
	}

	} // namespace implementation
	} // namespace V1_0
	} // namespace usb
	} // namespace hardware
	} // namespace android